using Pulumi;
using NewRelic = Pulumi.NewRelic;

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

}

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/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{
			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(400),
			},
			BigQuery: &cloud.GcpIntegrationsBigQueryArgs{
				MetricsPollingInterval: pulumi.Int(400),
				FetchTags:              pulumi.Bool(true),
			},
			BigTable: &cloud.GcpIntegrationsBigTableArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Composer: &cloud.GcpIntegrationsComposerArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			DataFlow: &cloud.GcpIntegrationsDataFlowArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			DataProc: &cloud.GcpIntegrationsDataProcArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			DataStore: &cloud.GcpIntegrationsDataStoreArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			FireBaseDatabase: &cloud.GcpIntegrationsFireBaseDatabaseArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			FireBaseHosting: &cloud.GcpIntegrationsFireBaseHostingArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			FireBaseStorage: &cloud.GcpIntegrationsFireBaseStorageArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			FireStore: &cloud.GcpIntegrationsFireStoreArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Functions: &cloud.GcpIntegrationsFunctionsArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Interconnect: &cloud.GcpIntegrationsInterconnectArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Kubernetes: &cloud.GcpIntegrationsKubernetesArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			LoadBalancing: &cloud.GcpIntegrationsLoadBalancingArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			MemCache: &cloud.GcpIntegrationsMemCacheArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			PubSub: &cloud.GcpIntegrationsPubSubArgs{
				MetricsPollingInterval: pulumi.Int(400),
				FetchTags:              pulumi.Bool(true),
			},
			Redis: &cloud.GcpIntegrationsRedisArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Router: &cloud.GcpIntegrationsRouterArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Run: &cloud.GcpIntegrationsRunArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Spanner: &cloud.GcpIntegrationsSpannerArgs{
				MetricsPollingInterval: pulumi.Int(400),
				FetchTags:              pulumi.Bool(true),
			},
			Sql: &cloud.GcpIntegrationsSqlArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			Storage: &cloud.GcpIntegrationsStorageArgs{
				MetricsPollingInterval: pulumi.Int(400),
				FetchTags:              pulumi.Bool(true),
			},
			VirtualMachines: &cloud.GcpIntegrationsVirtualMachinesArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
			VpcAccess: &cloud.GcpIntegrationsVpcAccessArgs{
				MetricsPollingInterval: pulumi.Int(400),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import java.util.*;
import java.io.*;
import java.nio.*;
import com.pulumi.*;

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()        
            .projectId("<Your GCP project ID>")
            .build());

        var foo1 = new GcpIntegrations("foo1", GcpIntegrationsArgs.builder()        
            .linkedAccountId(foo.getId())
            .appEngine(GcpIntegrationsAppEngine.builder()
                .metricsPollingInterval(400)
                .build())
            .bigQuery(GcpIntegrationsBigQuery.builder()
                .metricsPollingInterval(400)
                .fetchTags(true)
                .build())
            .bigTable(GcpIntegrationsBigTable.builder()
                .metricsPollingInterval(400)
                .build())
            .composer(GcpIntegrationsComposer.builder()
                .metricsPollingInterval(400)
                .build())
            .dataFlow(GcpIntegrationsDataFlow.builder()
                .metricsPollingInterval(400)
                .build())
            .dataProc(GcpIntegrationsDataProc.builder()
                .metricsPollingInterval(400)
                .build())
            .dataStore(GcpIntegrationsDataStore.builder()
                .metricsPollingInterval(400)
                .build())
            .fireBaseDatabase(GcpIntegrationsFireBaseDatabase.builder()
                .metricsPollingInterval(400)
                .build())
            .fireBaseHosting(GcpIntegrationsFireBaseHosting.builder()
                .metricsPollingInterval(400)
                .build())
            .fireBaseStorage(GcpIntegrationsFireBaseStorage.builder()
                .metricsPollingInterval(400)
                .build())
            .fireStore(GcpIntegrationsFireStore.builder()
                .metricsPollingInterval(400)
                .build())
            .functions(GcpIntegrationsFunctions.builder()
                .metricsPollingInterval(400)
                .build())
            .interconnect(GcpIntegrationsInterconnect.builder()
                .metricsPollingInterval(400)
                .build())
            .kubernetes(GcpIntegrationsKubernetes.builder()
                .metricsPollingInterval(400)
                .build())
            .loadBalancing(GcpIntegrationsLoadBalancing.builder()
                .metricsPollingInterval(400)
                .build())
            .memCache(GcpIntegrationsMemCache.builder()
                .metricsPollingInterval(400)
                .build())
            .pubSub(GcpIntegrationsPubSub.builder()
                .metricsPollingInterval(400)
                .fetchTags(true)
                .build())
            .redis(GcpIntegrationsRedis.builder()
                .metricsPollingInterval(400)
                .build())
            .router(GcpIntegrationsRouter.builder()
                .metricsPollingInterval(400)
                .build())
            .run(GcpIntegrationsRun.builder()
                .metricsPollingInterval(400)
                .build())
            .spanner(GcpIntegrationsSpanner.builder()
                .metricsPollingInterval(400)
                .fetchTags(true)
                .build())
            .sql(GcpIntegrationsSql.builder()
                .metricsPollingInterval(400)
                .build())
            .storage(GcpIntegrationsStorage.builder()
                .metricsPollingInterval(400)
                .fetchTags(true)
                .build())
            .virtualMachines(GcpIntegrationsVirtualMachines.builder()
                .metricsPollingInterval(400)
                .build())
            .vpcAccess(GcpIntegrationsVpcAccess.builder()
                .metricsPollingInterval(400)
                .build())
            .build());

        }
}

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.cloud.GcpLinkAccount("foo", project_id="<Your GCP project ID>")
foo1 = newrelic.cloud.GcpIntegrations("foo1",
    linked_account_id=foo.id,
    app_engine=newrelic.cloud.GcpIntegrationsAppEngineArgs(
        metrics_polling_interval=400,
    ),
    big_query=newrelic.cloud.GcpIntegrationsBigQueryArgs(
        metrics_polling_interval=400,
        fetch_tags=True,
    ),
    big_table=newrelic.cloud.GcpIntegrationsBigTableArgs(
        metrics_polling_interval=400,
    ),
    composer=newrelic.cloud.GcpIntegrationsComposerArgs(
        metrics_polling_interval=400,
    ),
    data_flow=newrelic.cloud.GcpIntegrationsDataFlowArgs(
        metrics_polling_interval=400,
    ),
    data_proc=newrelic.cloud.GcpIntegrationsDataProcArgs(
        metrics_polling_interval=400,
    ),
    data_store=newrelic.cloud.GcpIntegrationsDataStoreArgs(
        metrics_polling_interval=400,
    ),
    fire_base_database=newrelic.cloud.GcpIntegrationsFireBaseDatabaseArgs(
        metrics_polling_interval=400,
    ),
    fire_base_hosting=newrelic.cloud.GcpIntegrationsFireBaseHostingArgs(
        metrics_polling_interval=400,
    ),
    fire_base_storage=newrelic.cloud.GcpIntegrationsFireBaseStorageArgs(
        metrics_polling_interval=400,
    ),
    fire_store=newrelic.cloud.GcpIntegrationsFireStoreArgs(
        metrics_polling_interval=400,
    ),
    functions=newrelic.cloud.GcpIntegrationsFunctionsArgs(
        metrics_polling_interval=400,
    ),
    interconnect=newrelic.cloud.GcpIntegrationsInterconnectArgs(
        metrics_polling_interval=400,
    ),
    kubernetes=newrelic.cloud.GcpIntegrationsKubernetesArgs(
        metrics_polling_interval=400,
    ),
    load_balancing=newrelic.cloud.GcpIntegrationsLoadBalancingArgs(
        metrics_polling_interval=400,
    ),
    mem_cache=newrelic.cloud.GcpIntegrationsMemCacheArgs(
        metrics_polling_interval=400,
    ),
    pub_sub=newrelic.cloud.GcpIntegrationsPubSubArgs(
        metrics_polling_interval=400,
        fetch_tags=True,
    ),
    redis=newrelic.cloud.GcpIntegrationsRedisArgs(
        metrics_polling_interval=400,
    ),
    router=newrelic.cloud.GcpIntegrationsRouterArgs(
        metrics_polling_interval=400,
    ),
    run=newrelic.cloud.GcpIntegrationsRunArgs(
        metrics_polling_interval=400,
    ),
    spanner=newrelic.cloud.GcpIntegrationsSpannerArgs(
        metrics_polling_interval=400,
        fetch_tags=True,
    ),
    sql=newrelic.cloud.GcpIntegrationsSqlArgs(
        metrics_polling_interval=400,
    ),
    storage=newrelic.cloud.GcpIntegrationsStorageArgs(
        metrics_polling_interval=400,
        fetch_tags=True,
    ),
    virtual_machines=newrelic.cloud.GcpIntegrationsVirtualMachinesArgs(
        metrics_polling_interval=400,
    ),
    vpc_access=newrelic.cloud.GcpIntegrationsVpcAccessArgs(
        metrics_polling_interval=400,
    ))

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

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

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