newrelic.cloud.GcpIntegrations

import * as pulumi from "@pulumi/pulumi";
import * as newrelic from "@pulumi/newrelic";

const foo = new newrelic.cloud.GcpLinkAccount("foo", {
    name: "example",
    projectId: "<Your GCP project ID>",
});
const foo1 = new newrelic.cloud.GcpIntegrations("foo1", {
    linkedAccountId: foo.id,
    appEngine: {
        metricsPollingInterval: 300,
    },
    bigQuery: {
        metricsPollingInterval: 300,
        fetchTags: true,
    },
    bigTable: {
        metricsPollingInterval: 300,
    },
    composer: {
        metricsPollingInterval: 300,
    },
    dataFlow: {
        metricsPollingInterval: 300,
    },
    dataProc: {
        metricsPollingInterval: 300,
    },
    dataStore: {
        metricsPollingInterval: 300,
    },
    fireBaseDatabase: {
        metricsPollingInterval: 300,
    },
    fireBaseHosting: {
        metricsPollingInterval: 300,
    },
    fireBaseStorage: {
        metricsPollingInterval: 300,
    },
    fireStore: {
        metricsPollingInterval: 300,
    },
    functions: {
        metricsPollingInterval: 300,
    },
    interconnect: {
        metricsPollingInterval: 300,
    },
    kubernetes: {
        metricsPollingInterval: 300,
    },
    loadBalancing: {
        metricsPollingInterval: 300,
    },
    memCache: {
        metricsPollingInterval: 300,
    },
    pubSub: {
        metricsPollingInterval: 300,
        fetchTags: true,
    },
    redis: {
        metricsPollingInterval: 300,
    },
    router: {
        metricsPollingInterval: 300,
    },
    run: {
        metricsPollingInterval: 300,
    },
    spanner: {
        metricsPollingInterval: 300,
        fetchTags: true,
    },
    sql: {
        metricsPollingInterval: 300,
    },
    storage: {
        metricsPollingInterval: 300,
        fetchTags: true,
    },
    virtualMachines: {
        metricsPollingInterval: 300,
    },
    vpcAccess: {
        metricsPollingInterval: 300,
    },
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.cloud.GcpLinkAccount("foo",
    name="example",
    project_id="<Your GCP project ID>")
foo1 = newrelic.cloud.GcpIntegrations("foo1",
    linked_account_id=foo.id,
    app_engine={
        "metrics_polling_interval": 300,
    },
    big_query={
        "metrics_polling_interval": 300,
        "fetch_tags": True,
    },
    big_table={
        "metrics_polling_interval": 300,
    },
    composer={
        "metrics_polling_interval": 300,
    },
    data_flow={
        "metrics_polling_interval": 300,
    },
    data_proc={
        "metrics_polling_interval": 300,
    },
    data_store={
        "metrics_polling_interval": 300,
    },
    fire_base_database={
        "metrics_polling_interval": 300,
    },
    fire_base_hosting={
        "metrics_polling_interval": 300,
    },
    fire_base_storage={
        "metrics_polling_interval": 300,
    },
    fire_store={
        "metrics_polling_interval": 300,
    },
    functions={
        "metrics_polling_interval": 300,
    },
    interconnect={
        "metrics_polling_interval": 300,
    },
    kubernetes={
        "metrics_polling_interval": 300,
    },
    load_balancing={
        "metrics_polling_interval": 300,
    },
    mem_cache={
        "metrics_polling_interval": 300,
    },
    pub_sub={
        "metrics_polling_interval": 300,
        "fetch_tags": True,
    },
    redis={
        "metrics_polling_interval": 300,
    },
    router={
        "metrics_polling_interval": 300,
    },
    run={
        "metrics_polling_interval": 300,
    },
    spanner={
        "metrics_polling_interval": 300,
        "fetch_tags": True,
    },
    sql={
        "metrics_polling_interval": 300,
    },
    storage={
        "metrics_polling_interval": 300,
        "fetch_tags": True,
    },
    virtual_machines={
        "metrics_polling_interval": 300,
    },
    vpc_access={
        "metrics_polling_interval": 300,
    })

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v5/go/newrelic/cloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := cloud.NewGcpLinkAccount(ctx, "foo", &cloud.GcpLinkAccountArgs{
			Name:      pulumi.String("example"),
			ProjectId: pulumi.String("<Your GCP project ID>"),
		})
		if err != nil {
			return err
		}
		_, err = cloud.NewGcpIntegrations(ctx, "foo1", &cloud.GcpIntegrationsArgs{
			LinkedAccountId: foo.ID(),
			AppEngine: &cloud.GcpIntegrationsAppEngineArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			BigQuery: &cloud.GcpIntegrationsBigQueryArgs{
				MetricsPollingInterval: pulumi.Int(300),
				FetchTags:              pulumi.Bool(true),
			},
			BigTable: &cloud.GcpIntegrationsBigTableArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Composer: &cloud.GcpIntegrationsComposerArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			DataFlow: &cloud.GcpIntegrationsDataFlowArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			DataProc: &cloud.GcpIntegrationsDataProcArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			DataStore: &cloud.GcpIntegrationsDataStoreArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			FireBaseDatabase: &cloud.GcpIntegrationsFireBaseDatabaseArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			FireBaseHosting: &cloud.GcpIntegrationsFireBaseHostingArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			FireBaseStorage: &cloud.GcpIntegrationsFireBaseStorageArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			FireStore: &cloud.GcpIntegrationsFireStoreArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Functions: &cloud.GcpIntegrationsFunctionsArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Interconnect: &cloud.GcpIntegrationsInterconnectArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Kubernetes: &cloud.GcpIntegrationsKubernetesArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			LoadBalancing: &cloud.GcpIntegrationsLoadBalancingArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			MemCache: &cloud.GcpIntegrationsMemCacheArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			PubSub: &cloud.GcpIntegrationsPubSubArgs{
				MetricsPollingInterval: pulumi.Int(300),
				FetchTags:              pulumi.Bool(true),
			},
			Redis: &cloud.GcpIntegrationsRedisArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Router: &cloud.GcpIntegrationsRouterArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Run: &cloud.GcpIntegrationsRunArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Spanner: &cloud.GcpIntegrationsSpannerArgs{
				MetricsPollingInterval: pulumi.Int(300),
				FetchTags:              pulumi.Bool(true),
			},
			Sql: &cloud.GcpIntegrationsSqlArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			Storage: &cloud.GcpIntegrationsStorageArgs{
				MetricsPollingInterval: pulumi.Int(300),
				FetchTags:              pulumi.Bool(true),
			},
			VirtualMachines: &cloud.GcpIntegrationsVirtualMachinesArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
			VpcAccess: &cloud.GcpIntegrationsVpcAccessArgs{
				MetricsPollingInterval: pulumi.Int(300),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.Cloud.GcpLinkAccount("foo", new()
    {
        Name = "example",
        ProjectId = "<Your GCP project ID>",
    });

    var foo1 = new NewRelic.Cloud.GcpIntegrations("foo1", new()
    {
        LinkedAccountId = foo.Id,
        AppEngine = new NewRelic.Cloud.Inputs.GcpIntegrationsAppEngineArgs
        {
            MetricsPollingInterval = 300,
        },
        BigQuery = new NewRelic.Cloud.Inputs.GcpIntegrationsBigQueryArgs
        {
            MetricsPollingInterval = 300,
            FetchTags = true,
        },
        BigTable = new NewRelic.Cloud.Inputs.GcpIntegrationsBigTableArgs
        {
            MetricsPollingInterval = 300,
        },
        Composer = new NewRelic.Cloud.Inputs.GcpIntegrationsComposerArgs
        {
            MetricsPollingInterval = 300,
        },
        DataFlow = new NewRelic.Cloud.Inputs.GcpIntegrationsDataFlowArgs
        {
            MetricsPollingInterval = 300,
        },
        DataProc = new NewRelic.Cloud.Inputs.GcpIntegrationsDataProcArgs
        {
            MetricsPollingInterval = 300,
        },
        DataStore = new NewRelic.Cloud.Inputs.GcpIntegrationsDataStoreArgs
        {
            MetricsPollingInterval = 300,
        },
        FireBaseDatabase = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseDatabaseArgs
        {
            MetricsPollingInterval = 300,
        },
        FireBaseHosting = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseHostingArgs
        {
            MetricsPollingInterval = 300,
        },
        FireBaseStorage = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseStorageArgs
        {
            MetricsPollingInterval = 300,
        },
        FireStore = new NewRelic.Cloud.Inputs.GcpIntegrationsFireStoreArgs
        {
            MetricsPollingInterval = 300,
        },
        Functions = new NewRelic.Cloud.Inputs.GcpIntegrationsFunctionsArgs
        {
            MetricsPollingInterval = 300,
        },
        Interconnect = new NewRelic.Cloud.Inputs.GcpIntegrationsInterconnectArgs
        {
            MetricsPollingInterval = 300,
        },
        Kubernetes = new NewRelic.Cloud.Inputs.GcpIntegrationsKubernetesArgs
        {
            MetricsPollingInterval = 300,
        },
        LoadBalancing = new NewRelic.Cloud.Inputs.GcpIntegrationsLoadBalancingArgs
        {
            MetricsPollingInterval = 300,
        },
        MemCache = new NewRelic.Cloud.Inputs.GcpIntegrationsMemCacheArgs
        {
            MetricsPollingInterval = 300,
        },
        PubSub = new NewRelic.Cloud.Inputs.GcpIntegrationsPubSubArgs
        {
            MetricsPollingInterval = 300,
            FetchTags = true,
        },
        Redis = new NewRelic.Cloud.Inputs.GcpIntegrationsRedisArgs
        {
            MetricsPollingInterval = 300,
        },
        Router = new NewRelic.Cloud.Inputs.GcpIntegrationsRouterArgs
        {
            MetricsPollingInterval = 300,
        },
        Run = new NewRelic.Cloud.Inputs.GcpIntegrationsRunArgs
        {
            MetricsPollingInterval = 300,
        },
        Spanner = new NewRelic.Cloud.Inputs.GcpIntegrationsSpannerArgs
        {
            MetricsPollingInterval = 300,
            FetchTags = true,
        },
        Sql = new NewRelic.Cloud.Inputs.GcpIntegrationsSqlArgs
        {
            MetricsPollingInterval = 300,
        },
        Storage = new NewRelic.Cloud.Inputs.GcpIntegrationsStorageArgs
        {
            MetricsPollingInterval = 300,
            FetchTags = true,
        },
        VirtualMachines = new NewRelic.Cloud.Inputs.GcpIntegrationsVirtualMachinesArgs
        {
            MetricsPollingInterval = 300,
        },
        VpcAccess = new NewRelic.Cloud.Inputs.GcpIntegrationsVpcAccessArgs
        {
            MetricsPollingInterval = 300,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.cloud.GcpLinkAccount;
import com.pulumi.newrelic.cloud.GcpLinkAccountArgs;
import com.pulumi.newrelic.cloud.GcpIntegrations;
import com.pulumi.newrelic.cloud.GcpIntegrationsArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsAppEngineArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsBigQueryArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsBigTableArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsComposerArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsDataFlowArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsDataProcArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsDataStoreArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsFireBaseDatabaseArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsFireBaseHostingArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsFireBaseStorageArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsFireStoreArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsFunctionsArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsInterconnectArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsKubernetesArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsLoadBalancingArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsMemCacheArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsPubSubArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsRedisArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsRouterArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsRunArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsSpannerArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsSqlArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsStorageArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsVirtualMachinesArgs;
import com.pulumi.newrelic.cloud.inputs.GcpIntegrationsVpcAccessArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foo = new GcpLinkAccount("foo", GcpLinkAccountArgs.builder()
            .name("example")
            .projectId("<Your GCP project ID>")
            .build());

        var foo1 = new GcpIntegrations("foo1", GcpIntegrationsArgs.builder()
            .linkedAccountId(foo.id())
            .appEngine(GcpIntegrationsAppEngineArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .bigQuery(GcpIntegrationsBigQueryArgs.builder()
                .metricsPollingInterval(300)
                .fetchTags(true)
                .build())
            .bigTable(GcpIntegrationsBigTableArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .composer(GcpIntegrationsComposerArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .dataFlow(GcpIntegrationsDataFlowArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .dataProc(GcpIntegrationsDataProcArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .dataStore(GcpIntegrationsDataStoreArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .fireBaseDatabase(GcpIntegrationsFireBaseDatabaseArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .fireBaseHosting(GcpIntegrationsFireBaseHostingArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .fireBaseStorage(GcpIntegrationsFireBaseStorageArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .fireStore(GcpIntegrationsFireStoreArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .functions(GcpIntegrationsFunctionsArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .interconnect(GcpIntegrationsInterconnectArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .kubernetes(GcpIntegrationsKubernetesArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .loadBalancing(GcpIntegrationsLoadBalancingArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .memCache(GcpIntegrationsMemCacheArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .pubSub(GcpIntegrationsPubSubArgs.builder()
                .metricsPollingInterval(300)
                .fetchTags(true)
                .build())
            .redis(GcpIntegrationsRedisArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .router(GcpIntegrationsRouterArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .run(GcpIntegrationsRunArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .spanner(GcpIntegrationsSpannerArgs.builder()
                .metricsPollingInterval(300)
                .fetchTags(true)
                .build())
            .sql(GcpIntegrationsSqlArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .storage(GcpIntegrationsStorageArgs.builder()
                .metricsPollingInterval(300)
                .fetchTags(true)
                .build())
            .virtualMachines(GcpIntegrationsVirtualMachinesArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .vpcAccess(GcpIntegrationsVpcAccessArgs.builder()
                .metricsPollingInterval(300)
                .build())
            .build());

    }
}

resources:
  foo:
    type: newrelic:cloud:GcpLinkAccount
    properties:
      name: example
      projectId: <Your GCP project ID>
  foo1:
    type: newrelic:cloud:GcpIntegrations
    properties:
      linkedAccountId: ${foo.id}
      appEngine:
        metricsPollingInterval: 300
      bigQuery:
        metricsPollingInterval: 300
        fetchTags: true
      bigTable:
        metricsPollingInterval: 300
      composer:
        metricsPollingInterval: 300
      dataFlow:
        metricsPollingInterval: 300
      dataProc:
        metricsPollingInterval: 300
      dataStore:
        metricsPollingInterval: 300
      fireBaseDatabase:
        metricsPollingInterval: 300
      fireBaseHosting:
        metricsPollingInterval: 300
      fireBaseStorage:
        metricsPollingInterval: 300
      fireStore:
        metricsPollingInterval: 300
      functions:
        metricsPollingInterval: 300
      interconnect:
        metricsPollingInterval: 300
      kubernetes:
        metricsPollingInterval: 300
      loadBalancing:
        metricsPollingInterval: 300
      memCache:
        metricsPollingInterval: 300
      pubSub:
        metricsPollingInterval: 300
        fetchTags: true
      redis:
        metricsPollingInterval: 300
      router:
        metricsPollingInterval: 300
      run:
        metricsPollingInterval: 300
      spanner:
        metricsPollingInterval: 300
        fetchTags: true
      sql:
        metricsPollingInterval: 300
      storage:
        metricsPollingInterval: 300
        fetchTags: true
      virtualMachines:
        metricsPollingInterval: 300
      vpcAccess:
        metricsPollingInterval: 300

var gcpIntegrationsResource = new NewRelic.Cloud.GcpIntegrations("gcpIntegrationsResource", new()
{
    LinkedAccountId = "string",
    Interconnect = new NewRelic.Cloud.Inputs.GcpIntegrationsInterconnectArgs
    {
        MetricsPollingInterval = 0,
    },
    VpcAccess = new NewRelic.Cloud.Inputs.GcpIntegrationsVpcAccessArgs
    {
        MetricsPollingInterval = 0,
    },
    Functions = new NewRelic.Cloud.Inputs.GcpIntegrationsFunctionsArgs
    {
        MetricsPollingInterval = 0,
    },
    BigTable = new NewRelic.Cloud.Inputs.GcpIntegrationsBigTableArgs
    {
        MetricsPollingInterval = 0,
    },
    Composer = new NewRelic.Cloud.Inputs.GcpIntegrationsComposerArgs
    {
        MetricsPollingInterval = 0,
    },
    DataFlow = new NewRelic.Cloud.Inputs.GcpIntegrationsDataFlowArgs
    {
        MetricsPollingInterval = 0,
    },
    DataProc = new NewRelic.Cloud.Inputs.GcpIntegrationsDataProcArgs
    {
        MetricsPollingInterval = 0,
    },
    DataStore = new NewRelic.Cloud.Inputs.GcpIntegrationsDataStoreArgs
    {
        MetricsPollingInterval = 0,
    },
    FireBaseDatabase = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseDatabaseArgs
    {
        MetricsPollingInterval = 0,
    },
    FireBaseHosting = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseHostingArgs
    {
        MetricsPollingInterval = 0,
    },
    FireBaseStorage = new NewRelic.Cloud.Inputs.GcpIntegrationsFireBaseStorageArgs
    {
        MetricsPollingInterval = 0,
    },
    FireStore = new NewRelic.Cloud.Inputs.GcpIntegrationsFireStoreArgs
    {
        MetricsPollingInterval = 0,
    },
    BigQuery = new NewRelic.Cloud.Inputs.GcpIntegrationsBigQueryArgs
    {
        FetchTags = false,
        MetricsPollingInterval = 0,
    },
    AppEngine = new NewRelic.Cloud.Inputs.GcpIntegrationsAppEngineArgs
    {
        MetricsPollingInterval = 0,
    },
    Run = new NewRelic.Cloud.Inputs.GcpIntegrationsRunArgs
    {
        MetricsPollingInterval = 0,
    },
    AlloyDb = new NewRelic.Cloud.Inputs.GcpIntegrationsAlloyDbArgs
    {
        MetricsPollingInterval = 0,
    },
    LoadBalancing = new NewRelic.Cloud.Inputs.GcpIntegrationsLoadBalancingArgs
    {
        MetricsPollingInterval = 0,
    },
    MemCache = new NewRelic.Cloud.Inputs.GcpIntegrationsMemCacheArgs
    {
        MetricsPollingInterval = 0,
    },
    PubSub = new NewRelic.Cloud.Inputs.GcpIntegrationsPubSubArgs
    {
        FetchTags = false,
        MetricsPollingInterval = 0,
    },
    Redis = new NewRelic.Cloud.Inputs.GcpIntegrationsRedisArgs
    {
        MetricsPollingInterval = 0,
    },
    Router = new NewRelic.Cloud.Inputs.GcpIntegrationsRouterArgs
    {
        MetricsPollingInterval = 0,
    },
    Kubernetes = new NewRelic.Cloud.Inputs.GcpIntegrationsKubernetesArgs
    {
        MetricsPollingInterval = 0,
    },
    Spanner = new NewRelic.Cloud.Inputs.GcpIntegrationsSpannerArgs
    {
        FetchTags = false,
        MetricsPollingInterval = 0,
    },
    Sql = new NewRelic.Cloud.Inputs.GcpIntegrationsSqlArgs
    {
        MetricsPollingInterval = 0,
    },
    Storage = new NewRelic.Cloud.Inputs.GcpIntegrationsStorageArgs
    {
        FetchTags = false,
        MetricsPollingInterval = 0,
    },
    VirtualMachines = new NewRelic.Cloud.Inputs.GcpIntegrationsVirtualMachinesArgs
    {
        MetricsPollingInterval = 0,
    },
    AccountId = "string",
});

example, err := cloud.NewGcpIntegrations(ctx, "gcpIntegrationsResource", &cloud.GcpIntegrationsArgs{
	LinkedAccountId: pulumi.String("string"),
	Interconnect: &cloud.GcpIntegrationsInterconnectArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	VpcAccess: &cloud.GcpIntegrationsVpcAccessArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Functions: &cloud.GcpIntegrationsFunctionsArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	BigTable: &cloud.GcpIntegrationsBigTableArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Composer: &cloud.GcpIntegrationsComposerArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	DataFlow: &cloud.GcpIntegrationsDataFlowArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	DataProc: &cloud.GcpIntegrationsDataProcArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	DataStore: &cloud.GcpIntegrationsDataStoreArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	FireBaseDatabase: &cloud.GcpIntegrationsFireBaseDatabaseArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	FireBaseHosting: &cloud.GcpIntegrationsFireBaseHostingArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	FireBaseStorage: &cloud.GcpIntegrationsFireBaseStorageArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	FireStore: &cloud.GcpIntegrationsFireStoreArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	BigQuery: &cloud.GcpIntegrationsBigQueryArgs{
		FetchTags:              pulumi.Bool(false),
		MetricsPollingInterval: pulumi.Int(0),
	},
	AppEngine: &cloud.GcpIntegrationsAppEngineArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Run: &cloud.GcpIntegrationsRunArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	AlloyDb: &cloud.GcpIntegrationsAlloyDbArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	LoadBalancing: &cloud.GcpIntegrationsLoadBalancingArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	MemCache: &cloud.GcpIntegrationsMemCacheArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	PubSub: &cloud.GcpIntegrationsPubSubArgs{
		FetchTags:              pulumi.Bool(false),
		MetricsPollingInterval: pulumi.Int(0),
	},
	Redis: &cloud.GcpIntegrationsRedisArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Router: &cloud.GcpIntegrationsRouterArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Kubernetes: &cloud.GcpIntegrationsKubernetesArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Spanner: &cloud.GcpIntegrationsSpannerArgs{
		FetchTags:              pulumi.Bool(false),
		MetricsPollingInterval: pulumi.Int(0),
	},
	Sql: &cloud.GcpIntegrationsSqlArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	Storage: &cloud.GcpIntegrationsStorageArgs{
		FetchTags:              pulumi.Bool(false),
		MetricsPollingInterval: pulumi.Int(0),
	},
	VirtualMachines: &cloud.GcpIntegrationsVirtualMachinesArgs{
		MetricsPollingInterval: pulumi.Int(0),
	},
	AccountId: pulumi.String("string"),
})

var gcpIntegrationsResource = new GcpIntegrations("gcpIntegrationsResource", GcpIntegrationsArgs.builder()
    .linkedAccountId("string")
    .interconnect(GcpIntegrationsInterconnectArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .vpcAccess(GcpIntegrationsVpcAccessArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .functions(GcpIntegrationsFunctionsArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .bigTable(GcpIntegrationsBigTableArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .composer(GcpIntegrationsComposerArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .dataFlow(GcpIntegrationsDataFlowArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .dataProc(GcpIntegrationsDataProcArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .dataStore(GcpIntegrationsDataStoreArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .fireBaseDatabase(GcpIntegrationsFireBaseDatabaseArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .fireBaseHosting(GcpIntegrationsFireBaseHostingArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .fireBaseStorage(GcpIntegrationsFireBaseStorageArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .fireStore(GcpIntegrationsFireStoreArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .bigQuery(GcpIntegrationsBigQueryArgs.builder()
        .fetchTags(false)
        .metricsPollingInterval(0)
        .build())
    .appEngine(GcpIntegrationsAppEngineArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .run(GcpIntegrationsRunArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .alloyDb(GcpIntegrationsAlloyDbArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .loadBalancing(GcpIntegrationsLoadBalancingArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .memCache(GcpIntegrationsMemCacheArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .pubSub(GcpIntegrationsPubSubArgs.builder()
        .fetchTags(false)
        .metricsPollingInterval(0)
        .build())
    .redis(GcpIntegrationsRedisArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .router(GcpIntegrationsRouterArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .kubernetes(GcpIntegrationsKubernetesArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .spanner(GcpIntegrationsSpannerArgs.builder()
        .fetchTags(false)
        .metricsPollingInterval(0)
        .build())
    .sql(GcpIntegrationsSqlArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .storage(GcpIntegrationsStorageArgs.builder()
        .fetchTags(false)
        .metricsPollingInterval(0)
        .build())
    .virtualMachines(GcpIntegrationsVirtualMachinesArgs.builder()
        .metricsPollingInterval(0)
        .build())
    .accountId("string")
    .build());

gcp_integrations_resource = newrelic.cloud.GcpIntegrations("gcpIntegrationsResource",
    linked_account_id="string",
    interconnect={
        "metrics_polling_interval": 0,
    },
    vpc_access={
        "metrics_polling_interval": 0,
    },
    functions={
        "metrics_polling_interval": 0,
    },
    big_table={
        "metrics_polling_interval": 0,
    },
    composer={
        "metrics_polling_interval": 0,
    },
    data_flow={
        "metrics_polling_interval": 0,
    },
    data_proc={
        "metrics_polling_interval": 0,
    },
    data_store={
        "metrics_polling_interval": 0,
    },
    fire_base_database={
        "metrics_polling_interval": 0,
    },
    fire_base_hosting={
        "metrics_polling_interval": 0,
    },
    fire_base_storage={
        "metrics_polling_interval": 0,
    },
    fire_store={
        "metrics_polling_interval": 0,
    },
    big_query={
        "fetch_tags": False,
        "metrics_polling_interval": 0,
    },
    app_engine={
        "metrics_polling_interval": 0,
    },
    run={
        "metrics_polling_interval": 0,
    },
    alloy_db={
        "metrics_polling_interval": 0,
    },
    load_balancing={
        "metrics_polling_interval": 0,
    },
    mem_cache={
        "metrics_polling_interval": 0,
    },
    pub_sub={
        "fetch_tags": False,
        "metrics_polling_interval": 0,
    },
    redis={
        "metrics_polling_interval": 0,
    },
    router={
        "metrics_polling_interval": 0,
    },
    kubernetes={
        "metrics_polling_interval": 0,
    },
    spanner={
        "fetch_tags": False,
        "metrics_polling_interval": 0,
    },
    sql={
        "metrics_polling_interval": 0,
    },
    storage={
        "fetch_tags": False,
        "metrics_polling_interval": 0,
    },
    virtual_machines={
        "metrics_polling_interval": 0,
    },
    account_id="string")

const gcpIntegrationsResource = new newrelic.cloud.GcpIntegrations("gcpIntegrationsResource", {
    linkedAccountId: "string",
    interconnect: {
        metricsPollingInterval: 0,
    },
    vpcAccess: {
        metricsPollingInterval: 0,
    },
    functions: {
        metricsPollingInterval: 0,
    },
    bigTable: {
        metricsPollingInterval: 0,
    },
    composer: {
        metricsPollingInterval: 0,
    },
    dataFlow: {
        metricsPollingInterval: 0,
    },
    dataProc: {
        metricsPollingInterval: 0,
    },
    dataStore: {
        metricsPollingInterval: 0,
    },
    fireBaseDatabase: {
        metricsPollingInterval: 0,
    },
    fireBaseHosting: {
        metricsPollingInterval: 0,
    },
    fireBaseStorage: {
        metricsPollingInterval: 0,
    },
    fireStore: {
        metricsPollingInterval: 0,
    },
    bigQuery: {
        fetchTags: false,
        metricsPollingInterval: 0,
    },
    appEngine: {
        metricsPollingInterval: 0,
    },
    run: {
        metricsPollingInterval: 0,
    },
    alloyDb: {
        metricsPollingInterval: 0,
    },
    loadBalancing: {
        metricsPollingInterval: 0,
    },
    memCache: {
        metricsPollingInterval: 0,
    },
    pubSub: {
        fetchTags: false,
        metricsPollingInterval: 0,
    },
    redis: {
        metricsPollingInterval: 0,
    },
    router: {
        metricsPollingInterval: 0,
    },
    kubernetes: {
        metricsPollingInterval: 0,
    },
    spanner: {
        fetchTags: false,
        metricsPollingInterval: 0,
    },
    sql: {
        metricsPollingInterval: 0,
    },
    storage: {
        fetchTags: false,
        metricsPollingInterval: 0,
    },
    virtualMachines: {
        metricsPollingInterval: 0,
    },
    accountId: "string",
});

type: newrelic:cloud:GcpIntegrations
properties:
    accountId: string
    alloyDb:
        metricsPollingInterval: 0
    appEngine:
        metricsPollingInterval: 0
    bigQuery:
        fetchTags: false
        metricsPollingInterval: 0
    bigTable:
        metricsPollingInterval: 0
    composer:
        metricsPollingInterval: 0
    dataFlow:
        metricsPollingInterval: 0
    dataProc:
        metricsPollingInterval: 0
    dataStore:
        metricsPollingInterval: 0
    fireBaseDatabase:
        metricsPollingInterval: 0
    fireBaseHosting:
        metricsPollingInterval: 0
    fireBaseStorage:
        metricsPollingInterval: 0
    fireStore:
        metricsPollingInterval: 0
    functions:
        metricsPollingInterval: 0
    interconnect:
        metricsPollingInterval: 0
    kubernetes:
        metricsPollingInterval: 0
    linkedAccountId: string
    loadBalancing:
        metricsPollingInterval: 0
    memCache:
        metricsPollingInterval: 0
    pubSub:
        fetchTags: false
        metricsPollingInterval: 0
    redis:
        metricsPollingInterval: 0
    router:
        metricsPollingInterval: 0
    run:
        metricsPollingInterval: 0
    spanner:
        fetchTags: false
        metricsPollingInterval: 0
    sql:
        metricsPollingInterval: 0
    storage:
        fetchTags: false
        metricsPollingInterval: 0
    virtualMachines:
        metricsPollingInterval: 0
    vpcAccess:
        metricsPollingInterval: 0