pulumi-gcp-kotlin/com.pulumi.gcp.developerconnect.kotlin/AccountConnectorArgs

AccountConnectorArgs

data class AccountConnectorArgs(val accountConnectorId: Output<String>? = null, val annotations: Output<Map<String, String>>? = null, val labels: Output<Map<String, String>>? = null, val location: Output<String>? = null, val project: Output<String>? = null, val providerOauthConfig: Output<AccountConnectorProviderOauthConfigArgs>? = null) : ConvertibleToJava<AccountConnectorArgs>

Description

Example Usage

Developer Connect Account Connector Github

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GITHUB",
        scopes: ["repo"],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GITHUB",
        "scopes": ["repo"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GITHUB",
            Scopes = new[]
            {
                "repo",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GITHUB"),
				Scopes: pulumi.StringArray{
					pulumi.String("repo"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GITHUB")
                .scopes("repo")
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GITHUB
        scopes:
          - repo

Developer Connect Account Connector Gitlab

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GITLAB",
        scopes: ["api"],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GITLAB",
        "scopes": ["api"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GITLAB",
            Scopes = new[]
            {
                "api",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GITLAB"),
				Scopes: pulumi.StringArray{
					pulumi.String("api"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GITLAB")
                .scopes("api")
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GITLAB
        scopes:
          - api

Developer Connect Account Connector Google

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "GOOGLE",
        scopes: ["https://www&#46;googleapis&#46;com/auth/drive&#46;readonly"],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "GOOGLE",
        "scopes": ["https://www&#46;googleapis&#46;com/auth/drive&#46;readonly"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "GOOGLE",
            Scopes = new[]
            {
                "https://www.googleapis.com/auth/drive.readonly",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("GOOGLE"),
				Scopes: pulumi.StringArray{
					pulumi.String("https://www.googleapis.com/auth/drive.readonly"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("GOOGLE")
                .scopes("https://www.googleapis.com/auth/drive.readonly")
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: GOOGLE
        scopes:
          - https://www.googleapis.com/auth/drive.readonly

Developer Connect Account Connector Sentry

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "SENTRY",
        scopes: ["org:read"],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "SENTRY",
        "scopes": ["org:read"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "SENTRY",
            Scopes = new[]
            {
                "org:read",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("SENTRY"),
				Scopes: pulumi.StringArray{
					pulumi.String("org:read"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("SENTRY")
                .scopes("org:read")
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: SENTRY
        scopes:
          - org:read

Developer Connect Account Connector Rovo

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "ROVO",
        scopes: ["rovo"],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "ROVO",
        "scopes": ["rovo"],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "ROVO",
            Scopes = new[]
            {
                "rovo",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("ROVO"),
				Scopes: pulumi.StringArray{
					pulumi.String("rovo"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("ROVO")
                .scopes("rovo")
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: ROVO
        scopes:
          - rovo

Developer Connect Account Connector New Relic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "NEW_RELIC",
        scopes: [],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "NEW_RELIC",
        "scopes": [],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "NEW_RELIC",
            Scopes = new() { },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("NEW_RELIC"),
				Scopes:           pulumi.StringArray{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("NEW_RELIC")
                .scopes()
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: NEW_RELIC
        scopes: []

Developer Connect Account Connector Datastax

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_account_connector = new gcp.developerconnect.AccountConnector("my-account-connector", {
    location: "us-central1",
    accountConnectorId: "tf-test-ac",
    providerOauthConfig: {
        systemProviderId: "DATASTAX",
        scopes: [],
    },
});

import pulumi
import pulumi_gcp as gcp
my_account_connector = gcp.developerconnect.AccountConnector("my-account-connector",
    location="us-central1",
    account_connector_id="tf-test-ac",
    provider_oauth_config={
        "system_provider_id": "DATASTAX",
        "scopes": [],
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_account_connector = new Gcp.DeveloperConnect.AccountConnector("my-account-connector", new()
    {
        Location = "us-central1",
        AccountConnectorId = "tf-test-ac",
        ProviderOauthConfig = new Gcp.DeveloperConnect.Inputs.AccountConnectorProviderOauthConfigArgs
        {
            SystemProviderId = "DATASTAX",
            Scopes = new() { },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/developerconnect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := developerconnect.NewAccountConnector(ctx, "my-account-connector", &developerconnect.AccountConnectorArgs{
			Location:           pulumi.String("us-central1"),
			AccountConnectorId: pulumi.String("tf-test-ac"),
			ProviderOauthConfig: &developerconnect.AccountConnectorProviderOauthConfigArgs{
				SystemProviderId: pulumi.String("DATASTAX"),
				Scopes:           pulumi.StringArray{},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.developerconnect.AccountConnector;
import com.pulumi.gcp.developerconnect.AccountConnectorArgs;
import com.pulumi.gcp.developerconnect.inputs.AccountConnectorProviderOauthConfigArgs;
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 my_account_connector = new AccountConnector("my-account-connector", AccountConnectorArgs.builder()
            .location("us-central1")
            .accountConnectorId("tf-test-ac")
            .providerOauthConfig(AccountConnectorProviderOauthConfigArgs.builder()
                .systemProviderId("DATASTAX")
                .scopes()
                .build())
            .build());
    }
}

resources:
  my-account-connector:
    type: gcp:developerconnect:AccountConnector
    properties:
      location: us-central1
      accountConnectorId: tf-test-ac
      providerOauthConfig:
        systemProviderId: DATASTAX
        scopes: []

Import

AccountConnector can be imported using any of these accepted formats:

projects/{{project}}/locations/{{location}}/accountConnectors/{{account_connector_id}}
{{project}}/{{location}}/{{account_connector_id}}
{{location}}/{{account_connector_id}} When using the pulumi import command, AccountConnector can be imported using one of the formats above. For example:

$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default projects/{{project}}/locations/{{location}}/accountConnectors/{{account_connector_id}}

$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default {{project}}/{{location}}/{{account_connector_id}}

$ pulumi import gcp:developerconnect/accountConnector:AccountConnector default {{location}}/{{account_connector_id}}

Constructors

AccountConnectorArgs

constructor(accountConnectorId: Output<String>? = null, annotations: Output<Map<String, String>>? = null, labels: Output<Map<String, String>>? = null, location: Output<String>? = null, project: Output<String>? = null, providerOauthConfig: Output<AccountConnectorProviderOauthConfigArgs>? = null)

Properties

accountConnectorId

val accountConnectorId: Output<String>? = null

Required. The ID to use for the AccountConnector, which will become the final component of the AccountConnector's resource name. Its format should adhere to https://google.aip.dev/122#resource-id-segments Names must be unique per-project per-location.

annotations

val annotations: Output<Map<String, String>>? = null

Optional. Allows users to store small amounts of arbitrary data. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.

labels

val labels: Output<Map<String, String>>? = null

Optional. Labels as key value pairs Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

location

val location: Output<String>? = null

The location of the resource.

project

val project: Output<String>? = null

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

providerOauthConfig

val providerOauthConfig: Output<AccountConnectorProviderOauthConfigArgs>? = null

ProviderOAuthConfig is the OAuth config for a provider. Structure is documented below.

Functions

toJava

open override fun toJava(): AccountConnectorArgs