cloudbuildv2

package
v7.20.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 24, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Connection 

type Connection struct {
	pulumi.CustomResourceState

	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapOutput `pulumi:"annotations"`
	// Output only. Server assigned timestamp for when the connection was created.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// If disabled is set to true, functionality is disabled for this connection. Repository based API methods and webhooks processing for repositories in this connection will be disabled.
	Disabled pulumi.BoolPtrOutput `pulumi:"disabled"`
	// All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through
	// Terraform, other clients and services.
	EffectiveAnnotations pulumi.StringMapOutput `pulumi:"effectiveAnnotations"`
	// This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// Configuration for connections to github.com.
	// Structure is documented below.
	GithubConfig ConnectionGithubConfigPtrOutput `pulumi:"githubConfig"`
	// Configuration for connections to an instance of GitHub Enterprise.
	// Structure is documented below.
	GithubEnterpriseConfig ConnectionGithubEnterpriseConfigPtrOutput `pulumi:"githubEnterpriseConfig"`
	// Configuration for connections to gitlab.com or an instance of GitLab Enterprise.
	// Structure is documented below.
	GitlabConfig ConnectionGitlabConfigPtrOutput `pulumi:"gitlabConfig"`
	// Output only. Installation state of the Connection.
	// Structure is documented below.
	InstallationStates ConnectionInstallationStateArrayOutput `pulumi:"installationStates"`
	// The location for the resource
	//
	// ***
	Location pulumi.StringOutput `pulumi:"location"`
	// Immutable. The resource name of the connection.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// Output only. Set to true when the connection is being set up or updated in the background.
	Reconciling pulumi.BoolOutput `pulumi:"reconciling"`
	// Output only. Server assigned timestamp for when the connection was updated.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

A connection to a SCM like GitHub, GitHub Enterprise, Bitbucket Data Center or GitLab.

To get more information about Connection, see:

* [API documentation](https://cloud.google.com/build/docs/api/reference/rest) * How-to Guides

## Example Usage

### Cloudbuildv2 Connection

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnection(ctx, "my-connection", &cloudbuildv2.ConnectionArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("tf-test-connection"),
			GithubConfig: &cloudbuildv2.ConnectionGithubConfigArgs{
				AppInstallationId: pulumi.Int(0),
				AuthorizerCredential: &cloudbuildv2.ConnectionGithubConfigAuthorizerCredentialArgs{
					OauthTokenSecretVersion: pulumi.String("projects/gcb-terraform-creds/secrets/github-pat/versions/1"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Cloudbuildv2 Connection Ghe

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/secretmanager"
"github.com/pulumi/pulumi-std/sdk/go/std"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "private-key-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("ghe-pk-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "private-key.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "private-key-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     private_key_secret.ID(),
			SecretData: invokeFile.Result,
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecret(ctx, "webhook-secret-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("github-token-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "webhook-secret-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     webhook_secret_secret.ID(),
			SecretData: pulumi.String("<webhook-secret-data>"),
		})
		if err != nil {
			return err
		}
		p4sa_secretAccessor, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/secretmanager.secretAccessor",
					Members: []string{
						"serviceAccount:service-123456789@gcp-sa-cloudbuild.iam.gserviceaccount.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy-pk", &secretmanager.SecretIamPolicyArgs{
			SecretId:   private_key_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy-whs", &secretmanager.SecretIamPolicyArgs{
			SecretId:   webhook_secret_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnection(ctx, "my-connection", &cloudbuildv2.ConnectionArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("my-terraform-ghe-connection"),
			GithubEnterpriseConfig: &cloudbuildv2.ConnectionGithubEnterpriseConfigArgs{
				HostUri:                    pulumi.String("https://ghe.com"),
				PrivateKeySecretVersion:    private_key_secret_version.ID(),
				WebhookSecretSecretVersion: webhook_secret_secret_version.ID(),
				AppId:                      pulumi.Int(200),
				AppSlug:                    pulumi.String("gcb-app"),
				AppInstallationId:          pulumi.Int(300),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Cloudbuildv2 Connection Github

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/secretmanager"
"github.com/pulumi/pulumi-std/sdk/go/std"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "github-token-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("github-token-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "my-github-token.txt",
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "github-token-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     github_token_secret.ID(),
			SecretData: invokeFile.Result,
		})
		if err != nil {
			return err
		}
		p4sa_secretAccessor, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/secretmanager.secretAccessor",
					Members: []string{
						"serviceAccount:service-123456789@gcp-sa-cloudbuild.iam.gserviceaccount.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy", &secretmanager.SecretIamPolicyArgs{
			SecretId:   github_token_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnection(ctx, "my-connection", &cloudbuildv2.ConnectionArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("my-connection"),
			GithubConfig: &cloudbuildv2.ConnectionGithubConfigArgs{
				AppInstallationId: pulumi.Int(123123),
				AuthorizerCredential: &cloudbuildv2.ConnectionGithubConfigAuthorizerCredentialArgs{
					OauthTokenSecretVersion: github_token_secret_version.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Connection can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/connections/{{name}}`

* `{{project}}/{{location}}/{{name}}`

* `{{location}}/{{name}}`

* `{{name}}`

When using the `pulumi import` command, Connection can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:cloudbuildv2/connection:Connection default projects/{{project}}/locations/{{location}}/connections/{{name}} ```

```sh $ pulumi import gcp:cloudbuildv2/connection:Connection default {{project}}/{{location}}/{{name}} ```

```sh $ pulumi import gcp:cloudbuildv2/connection:Connection default {{location}}/{{name}} ```

```sh $ pulumi import gcp:cloudbuildv2/connection:Connection default {{name}} ```

func GetConnection 

func GetConnection(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectionState, opts ...pulumi.ResourceOption) (*Connection, error)

GetConnection gets an existing Connection resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConnection 

func NewConnection(ctx *pulumi.Context,
	name string, args *ConnectionArgs, opts ...pulumi.ResourceOption) (*Connection, error)

NewConnection registers a new resource with the given unique name, arguments, and options.

func (*Connection) ElementType 

func (*Connection) ElementType() reflect.Type

func (*Connection) ToConnectionOutput 

func (i *Connection) ToConnectionOutput() ConnectionOutput

func (*Connection) ToConnectionOutputWithContext 

func (i *Connection) ToConnectionOutputWithContext(ctx context.Context) ConnectionOutput

type ConnectionArgs 

type ConnectionArgs struct {
	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapInput
	// If disabled is set to true, functionality is disabled for this connection. Repository based API methods and webhooks processing for repositories in this connection will be disabled.
	Disabled pulumi.BoolPtrInput
	// Configuration for connections to github.com.
	// Structure is documented below.
	GithubConfig ConnectionGithubConfigPtrInput
	// Configuration for connections to an instance of GitHub Enterprise.
	// Structure is documented below.
	GithubEnterpriseConfig ConnectionGithubEnterpriseConfigPtrInput
	// Configuration for connections to gitlab.com or an instance of GitLab Enterprise.
	// Structure is documented below.
	GitlabConfig ConnectionGitlabConfigPtrInput
	// The location for the resource
	//
	// ***
	Location pulumi.StringInput
	// Immutable. The resource name of the connection.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a Connection resource.

func (ConnectionArgs) ElementType 

func (ConnectionArgs) ElementType() reflect.Type

type ConnectionArray 

type ConnectionArray []ConnectionInput

func (ConnectionArray) ElementType 

func (ConnectionArray) ElementType() reflect.Type

func (ConnectionArray) ToConnectionArrayOutput 

func (i ConnectionArray) ToConnectionArrayOutput() ConnectionArrayOutput

func (ConnectionArray) ToConnectionArrayOutputWithContext 

func (i ConnectionArray) ToConnectionArrayOutputWithContext(ctx context.Context) ConnectionArrayOutput

type ConnectionArrayInput 

type ConnectionArrayInput interface {
	pulumi.Input

	ToConnectionArrayOutput() ConnectionArrayOutput
	ToConnectionArrayOutputWithContext(context.Context) ConnectionArrayOutput
}

ConnectionArrayInput is an input type that accepts ConnectionArray and ConnectionArrayOutput values. You can construct a concrete instance of `ConnectionArrayInput` via: 

ConnectionArray{ ConnectionArgs{...} }

type ConnectionArrayOutput 

type ConnectionArrayOutput struct{ *pulumi.OutputState }

func (ConnectionArrayOutput) ElementType 

func (ConnectionArrayOutput) ElementType() reflect.Type

func (ConnectionArrayOutput) Index 

func (o ConnectionArrayOutput) Index(i pulumi.IntInput) ConnectionOutput

func (ConnectionArrayOutput) ToConnectionArrayOutput 

func (o ConnectionArrayOutput) ToConnectionArrayOutput() ConnectionArrayOutput

func (ConnectionArrayOutput) ToConnectionArrayOutputWithContext 

func (o ConnectionArrayOutput) ToConnectionArrayOutputWithContext(ctx context.Context) ConnectionArrayOutput

type ConnectionGithubConfig 

type ConnectionGithubConfig struct {
	// GitHub App installation id.
	AppInstallationId *int `pulumi:"appInstallationId"`
	// OAuth credential of the account that authorized the Cloud Build GitHub App. It is recommended to use a robot account instead of a human user account. The OAuth token must be tied to the Cloud Build GitHub App.
	// Structure is documented below.
	AuthorizerCredential *ConnectionGithubConfigAuthorizerCredential `pulumi:"authorizerCredential"`
}

type ConnectionGithubConfigArgs 

type ConnectionGithubConfigArgs struct {
	// GitHub App installation id.
	AppInstallationId pulumi.IntPtrInput `pulumi:"appInstallationId"`
	// OAuth credential of the account that authorized the Cloud Build GitHub App. It is recommended to use a robot account instead of a human user account. The OAuth token must be tied to the Cloud Build GitHub App.
	// Structure is documented below.
	AuthorizerCredential ConnectionGithubConfigAuthorizerCredentialPtrInput `pulumi:"authorizerCredential"`
}

func (ConnectionGithubConfigArgs) ElementType 

func (ConnectionGithubConfigArgs) ElementType() reflect.Type

func (ConnectionGithubConfigArgs) ToConnectionGithubConfigOutput 

func (i ConnectionGithubConfigArgs) ToConnectionGithubConfigOutput() ConnectionGithubConfigOutput

func (ConnectionGithubConfigArgs) ToConnectionGithubConfigOutputWithContext 

func (i ConnectionGithubConfigArgs) ToConnectionGithubConfigOutputWithContext(ctx context.Context) ConnectionGithubConfigOutput

func (ConnectionGithubConfigArgs) ToConnectionGithubConfigPtrOutput 

func (i ConnectionGithubConfigArgs) ToConnectionGithubConfigPtrOutput() ConnectionGithubConfigPtrOutput

func (ConnectionGithubConfigArgs) ToConnectionGithubConfigPtrOutputWithContext 

func (i ConnectionGithubConfigArgs) ToConnectionGithubConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigPtrOutput

type ConnectionGithubConfigAuthorizerCredential 

type ConnectionGithubConfigAuthorizerCredential struct {
	// A SecretManager resource containing the OAuth token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	OauthTokenSecretVersion *string `pulumi:"oauthTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username *string `pulumi:"username"`
}

type ConnectionGithubConfigAuthorizerCredentialArgs 

type ConnectionGithubConfigAuthorizerCredentialArgs struct {
	// A SecretManager resource containing the OAuth token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	OauthTokenSecretVersion pulumi.StringPtrInput `pulumi:"oauthTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (ConnectionGithubConfigAuthorizerCredentialArgs) ElementType 

func (ConnectionGithubConfigAuthorizerCredentialArgs) ElementType() reflect.Type

func (ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialOutput 

func (i ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialOutput() ConnectionGithubConfigAuthorizerCredentialOutput

func (ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialOutputWithContext 

func (i ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGithubConfigAuthorizerCredentialOutput

func (ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialPtrOutput 

func (i ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialPtrOutput() ConnectionGithubConfigAuthorizerCredentialPtrOutput

func (ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext 

func (i ConnectionGithubConfigAuthorizerCredentialArgs) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigAuthorizerCredentialPtrOutput

type ConnectionGithubConfigAuthorizerCredentialInput 

type ConnectionGithubConfigAuthorizerCredentialInput interface {
	pulumi.Input

	ToConnectionGithubConfigAuthorizerCredentialOutput() ConnectionGithubConfigAuthorizerCredentialOutput
	ToConnectionGithubConfigAuthorizerCredentialOutputWithContext(context.Context) ConnectionGithubConfigAuthorizerCredentialOutput
}

ConnectionGithubConfigAuthorizerCredentialInput is an input type that accepts ConnectionGithubConfigAuthorizerCredentialArgs and ConnectionGithubConfigAuthorizerCredentialOutput values. You can construct a concrete instance of `ConnectionGithubConfigAuthorizerCredentialInput` via: 

ConnectionGithubConfigAuthorizerCredentialArgs{...}

type ConnectionGithubConfigAuthorizerCredentialOutput 

type ConnectionGithubConfigAuthorizerCredentialOutput struct{ *pulumi.OutputState }

func (ConnectionGithubConfigAuthorizerCredentialOutput) ElementType 

func (ConnectionGithubConfigAuthorizerCredentialOutput) ElementType() reflect.Type

func (ConnectionGithubConfigAuthorizerCredentialOutput) OauthTokenSecretVersion 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) OauthTokenSecretVersion() pulumi.StringPtrOutput

A SecretManager resource containing the OAuth token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialOutput 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialOutput() ConnectionGithubConfigAuthorizerCredentialOutput

func (ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialOutputWithContext 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGithubConfigAuthorizerCredentialOutput

func (ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutput 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutput() ConnectionGithubConfigAuthorizerCredentialPtrOutput

func (ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigAuthorizerCredentialPtrOutput

func (ConnectionGithubConfigAuthorizerCredentialOutput) Username 

func (o ConnectionGithubConfigAuthorizerCredentialOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGithubConfigAuthorizerCredentialPtrInput 

type ConnectionGithubConfigAuthorizerCredentialPtrInput interface {
	pulumi.Input

	ToConnectionGithubConfigAuthorizerCredentialPtrOutput() ConnectionGithubConfigAuthorizerCredentialPtrOutput
	ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext(context.Context) ConnectionGithubConfigAuthorizerCredentialPtrOutput
}

ConnectionGithubConfigAuthorizerCredentialPtrInput is an input type that accepts ConnectionGithubConfigAuthorizerCredentialArgs, ConnectionGithubConfigAuthorizerCredentialPtr and ConnectionGithubConfigAuthorizerCredentialPtrOutput values. You can construct a concrete instance of `ConnectionGithubConfigAuthorizerCredentialPtrInput` via: 

        ConnectionGithubConfigAuthorizerCredentialArgs{...}

or:

        nil

func ConnectionGithubConfigAuthorizerCredentialPtr 

func ConnectionGithubConfigAuthorizerCredentialPtr(v *ConnectionGithubConfigAuthorizerCredentialArgs) ConnectionGithubConfigAuthorizerCredentialPtrInput

type ConnectionGithubConfigAuthorizerCredentialPtrOutput 

type ConnectionGithubConfigAuthorizerCredentialPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) Elem 

func (o ConnectionGithubConfigAuthorizerCredentialPtrOutput) Elem() ConnectionGithubConfigAuthorizerCredentialOutput

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) ElementType 

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) ElementType() reflect.Type

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) OauthTokenSecretVersion 

func (o ConnectionGithubConfigAuthorizerCredentialPtrOutput) OauthTokenSecretVersion() pulumi.StringPtrOutput

A SecretManager resource containing the OAuth token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutput 

func (o ConnectionGithubConfigAuthorizerCredentialPtrOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutput() ConnectionGithubConfigAuthorizerCredentialPtrOutput

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGithubConfigAuthorizerCredentialPtrOutput) ToConnectionGithubConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigAuthorizerCredentialPtrOutput

func (ConnectionGithubConfigAuthorizerCredentialPtrOutput) Username 

func (o ConnectionGithubConfigAuthorizerCredentialPtrOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGithubConfigInput 

type ConnectionGithubConfigInput interface {
	pulumi.Input

	ToConnectionGithubConfigOutput() ConnectionGithubConfigOutput
	ToConnectionGithubConfigOutputWithContext(context.Context) ConnectionGithubConfigOutput
}

ConnectionGithubConfigInput is an input type that accepts ConnectionGithubConfigArgs and ConnectionGithubConfigOutput values. You can construct a concrete instance of `ConnectionGithubConfigInput` via: 

ConnectionGithubConfigArgs{...}

type ConnectionGithubConfigOutput 

type ConnectionGithubConfigOutput struct{ *pulumi.OutputState }

func (ConnectionGithubConfigOutput) AppInstallationId 

func (o ConnectionGithubConfigOutput) AppInstallationId() pulumi.IntPtrOutput

GitHub App installation id.

func (ConnectionGithubConfigOutput) AuthorizerCredential 

func (o ConnectionGithubConfigOutput) AuthorizerCredential() ConnectionGithubConfigAuthorizerCredentialPtrOutput

OAuth credential of the account that authorized the Cloud Build GitHub App. It is recommended to use a robot account instead of a human user account. The OAuth token must be tied to the Cloud Build GitHub App. Structure is documented below.

func (ConnectionGithubConfigOutput) ElementType 

func (ConnectionGithubConfigOutput) ElementType() reflect.Type

func (ConnectionGithubConfigOutput) ToConnectionGithubConfigOutput 

func (o ConnectionGithubConfigOutput) ToConnectionGithubConfigOutput() ConnectionGithubConfigOutput

func (ConnectionGithubConfigOutput) ToConnectionGithubConfigOutputWithContext 

func (o ConnectionGithubConfigOutput) ToConnectionGithubConfigOutputWithContext(ctx context.Context) ConnectionGithubConfigOutput

func (ConnectionGithubConfigOutput) ToConnectionGithubConfigPtrOutput 

func (o ConnectionGithubConfigOutput) ToConnectionGithubConfigPtrOutput() ConnectionGithubConfigPtrOutput

func (ConnectionGithubConfigOutput) ToConnectionGithubConfigPtrOutputWithContext 

func (o ConnectionGithubConfigOutput) ToConnectionGithubConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigPtrOutput

type ConnectionGithubConfigPtrInput 

type ConnectionGithubConfigPtrInput interface {
	pulumi.Input

	ToConnectionGithubConfigPtrOutput() ConnectionGithubConfigPtrOutput
	ToConnectionGithubConfigPtrOutputWithContext(context.Context) ConnectionGithubConfigPtrOutput
}

ConnectionGithubConfigPtrInput is an input type that accepts ConnectionGithubConfigArgs, ConnectionGithubConfigPtr and ConnectionGithubConfigPtrOutput values. You can construct a concrete instance of `ConnectionGithubConfigPtrInput` via: 

        ConnectionGithubConfigArgs{...}

or:

        nil

func ConnectionGithubConfigPtr 

func ConnectionGithubConfigPtr(v *ConnectionGithubConfigArgs) ConnectionGithubConfigPtrInput

type ConnectionGithubConfigPtrOutput 

type ConnectionGithubConfigPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGithubConfigPtrOutput) AppInstallationId 

func (o ConnectionGithubConfigPtrOutput) AppInstallationId() pulumi.IntPtrOutput

GitHub App installation id.

func (ConnectionGithubConfigPtrOutput) AuthorizerCredential 

func (o ConnectionGithubConfigPtrOutput) AuthorizerCredential() ConnectionGithubConfigAuthorizerCredentialPtrOutput

OAuth credential of the account that authorized the Cloud Build GitHub App. It is recommended to use a robot account instead of a human user account. The OAuth token must be tied to the Cloud Build GitHub App. Structure is documented below.

func (ConnectionGithubConfigPtrOutput) Elem 

func (o ConnectionGithubConfigPtrOutput) Elem() ConnectionGithubConfigOutput

func (ConnectionGithubConfigPtrOutput) ElementType 

func (ConnectionGithubConfigPtrOutput) ElementType() reflect.Type

func (ConnectionGithubConfigPtrOutput) ToConnectionGithubConfigPtrOutput 

func (o ConnectionGithubConfigPtrOutput) ToConnectionGithubConfigPtrOutput() ConnectionGithubConfigPtrOutput

func (ConnectionGithubConfigPtrOutput) ToConnectionGithubConfigPtrOutputWithContext 

func (o ConnectionGithubConfigPtrOutput) ToConnectionGithubConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubConfigPtrOutput

type ConnectionGithubEnterpriseConfig 

type ConnectionGithubEnterpriseConfig struct {
	// Id of the GitHub App created from the manifest.
	AppId *int `pulumi:"appId"`
	// ID of the installation of the GitHub App.
	AppInstallationId *int `pulumi:"appInstallationId"`
	// The URL-friendly name of the GitHub App.
	AppSlug *string `pulumi:"appSlug"`
	// Required. The URI of the GitHub Enterprise host this connection is for.
	HostUri string `pulumi:"hostUri"`
	// SecretManager resource containing the private key of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.
	PrivateKeySecretVersion *string `pulumi:"privateKeySecretVersion"`
	// Configuration for using Service Directory to privately connect to a GitHub Enterprise server. This should only be set if the GitHub Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitHub Enterprise server will be made over the public internet.
	// Structure is documented below.
	ServiceDirectoryConfig *ConnectionGithubEnterpriseConfigServiceDirectoryConfig `pulumi:"serviceDirectoryConfig"`
	// SSL certificate to use for requests to GitHub Enterprise.
	SslCa *string `pulumi:"sslCa"`
	// SecretManager resource containing the webhook secret of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.
	WebhookSecretSecretVersion *string `pulumi:"webhookSecretSecretVersion"`
}

type ConnectionGithubEnterpriseConfigArgs 

type ConnectionGithubEnterpriseConfigArgs struct {
	// Id of the GitHub App created from the manifest.
	AppId pulumi.IntPtrInput `pulumi:"appId"`
	// ID of the installation of the GitHub App.
	AppInstallationId pulumi.IntPtrInput `pulumi:"appInstallationId"`
	// The URL-friendly name of the GitHub App.
	AppSlug pulumi.StringPtrInput `pulumi:"appSlug"`
	// Required. The URI of the GitHub Enterprise host this connection is for.
	HostUri pulumi.StringInput `pulumi:"hostUri"`
	// SecretManager resource containing the private key of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.
	PrivateKeySecretVersion pulumi.StringPtrInput `pulumi:"privateKeySecretVersion"`
	// Configuration for using Service Directory to privately connect to a GitHub Enterprise server. This should only be set if the GitHub Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitHub Enterprise server will be made over the public internet.
	// Structure is documented below.
	ServiceDirectoryConfig ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput `pulumi:"serviceDirectoryConfig"`
	// SSL certificate to use for requests to GitHub Enterprise.
	SslCa pulumi.StringPtrInput `pulumi:"sslCa"`
	// SecretManager resource containing the webhook secret of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.
	WebhookSecretSecretVersion pulumi.StringPtrInput `pulumi:"webhookSecretSecretVersion"`
}

func (ConnectionGithubEnterpriseConfigArgs) ElementType 

func (ConnectionGithubEnterpriseConfigArgs) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigOutput 

func (i ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigOutput() ConnectionGithubEnterpriseConfigOutput

func (ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigOutputWithContext 

func (i ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigOutput

func (ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigPtrOutput 

func (i ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigPtrOutput() ConnectionGithubEnterpriseConfigPtrOutput

func (ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigPtrOutputWithContext 

func (i ConnectionGithubEnterpriseConfigArgs) ToConnectionGithubEnterpriseConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigPtrOutput

type ConnectionGithubEnterpriseConfigInput 

type ConnectionGithubEnterpriseConfigInput interface {
	pulumi.Input

	ToConnectionGithubEnterpriseConfigOutput() ConnectionGithubEnterpriseConfigOutput
	ToConnectionGithubEnterpriseConfigOutputWithContext(context.Context) ConnectionGithubEnterpriseConfigOutput
}

ConnectionGithubEnterpriseConfigInput is an input type that accepts ConnectionGithubEnterpriseConfigArgs and ConnectionGithubEnterpriseConfigOutput values. You can construct a concrete instance of `ConnectionGithubEnterpriseConfigInput` via: 

ConnectionGithubEnterpriseConfigArgs{...}

type ConnectionGithubEnterpriseConfigOutput 

type ConnectionGithubEnterpriseConfigOutput struct{ *pulumi.OutputState }

func (ConnectionGithubEnterpriseConfigOutput) AppId 

func (o ConnectionGithubEnterpriseConfigOutput) AppId() pulumi.IntPtrOutput

Id of the GitHub App created from the manifest.

func (ConnectionGithubEnterpriseConfigOutput) AppInstallationId 

func (o ConnectionGithubEnterpriseConfigOutput) AppInstallationId() pulumi.IntPtrOutput

ID of the installation of the GitHub App.

func (ConnectionGithubEnterpriseConfigOutput) AppSlug 

func (o ConnectionGithubEnterpriseConfigOutput) AppSlug() pulumi.StringPtrOutput

The URL-friendly name of the GitHub App.

func (ConnectionGithubEnterpriseConfigOutput) ElementType 

func (ConnectionGithubEnterpriseConfigOutput) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigOutput) HostUri 

func (o ConnectionGithubEnterpriseConfigOutput) HostUri() pulumi.StringOutput

Required. The URI of the GitHub Enterprise host this connection is for.

func (ConnectionGithubEnterpriseConfigOutput) PrivateKeySecretVersion 

func (o ConnectionGithubEnterpriseConfigOutput) PrivateKeySecretVersion() pulumi.StringPtrOutput

SecretManager resource containing the private key of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.

func (ConnectionGithubEnterpriseConfigOutput) ServiceDirectoryConfig 

func (o ConnectionGithubEnterpriseConfigOutput) ServiceDirectoryConfig() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

Configuration for using Service Directory to privately connect to a GitHub Enterprise server. This should only be set if the GitHub Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitHub Enterprise server will be made over the public internet. Structure is documented below.

func (ConnectionGithubEnterpriseConfigOutput) SslCa 

func (o ConnectionGithubEnterpriseConfigOutput) SslCa() pulumi.StringPtrOutput

SSL certificate to use for requests to GitHub Enterprise.

func (ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigOutput 

func (o ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigOutput() ConnectionGithubEnterpriseConfigOutput

func (ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigOutputWithContext 

func (o ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigOutput

func (ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigPtrOutput 

func (o ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigPtrOutput() ConnectionGithubEnterpriseConfigPtrOutput

func (ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigPtrOutputWithContext 

func (o ConnectionGithubEnterpriseConfigOutput) ToConnectionGithubEnterpriseConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigPtrOutput

func (ConnectionGithubEnterpriseConfigOutput) WebhookSecretSecretVersion 

func (o ConnectionGithubEnterpriseConfigOutput) WebhookSecretSecretVersion() pulumi.StringPtrOutput

SecretManager resource containing the webhook secret of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.

type ConnectionGithubEnterpriseConfigPtrInput 

type ConnectionGithubEnterpriseConfigPtrInput interface {
	pulumi.Input

	ToConnectionGithubEnterpriseConfigPtrOutput() ConnectionGithubEnterpriseConfigPtrOutput
	ToConnectionGithubEnterpriseConfigPtrOutputWithContext(context.Context) ConnectionGithubEnterpriseConfigPtrOutput
}

ConnectionGithubEnterpriseConfigPtrInput is an input type that accepts ConnectionGithubEnterpriseConfigArgs, ConnectionGithubEnterpriseConfigPtr and ConnectionGithubEnterpriseConfigPtrOutput values. You can construct a concrete instance of `ConnectionGithubEnterpriseConfigPtrInput` via: 

        ConnectionGithubEnterpriseConfigArgs{...}

or:

        nil

func ConnectionGithubEnterpriseConfigPtr 

func ConnectionGithubEnterpriseConfigPtr(v *ConnectionGithubEnterpriseConfigArgs) ConnectionGithubEnterpriseConfigPtrInput

type ConnectionGithubEnterpriseConfigPtrOutput 

type ConnectionGithubEnterpriseConfigPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGithubEnterpriseConfigPtrOutput) AppId 

func (o ConnectionGithubEnterpriseConfigPtrOutput) AppId() pulumi.IntPtrOutput

Id of the GitHub App created from the manifest.

func (ConnectionGithubEnterpriseConfigPtrOutput) AppInstallationId 

func (o ConnectionGithubEnterpriseConfigPtrOutput) AppInstallationId() pulumi.IntPtrOutput

ID of the installation of the GitHub App.

func (ConnectionGithubEnterpriseConfigPtrOutput) AppSlug 

func (o ConnectionGithubEnterpriseConfigPtrOutput) AppSlug() pulumi.StringPtrOutput

The URL-friendly name of the GitHub App.

func (ConnectionGithubEnterpriseConfigPtrOutput) Elem 

func (o ConnectionGithubEnterpriseConfigPtrOutput) Elem() ConnectionGithubEnterpriseConfigOutput

func (ConnectionGithubEnterpriseConfigPtrOutput) ElementType 

func (ConnectionGithubEnterpriseConfigPtrOutput) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigPtrOutput) HostUri 

func (o ConnectionGithubEnterpriseConfigPtrOutput) HostUri() pulumi.StringPtrOutput

Required. The URI of the GitHub Enterprise host this connection is for.

func (ConnectionGithubEnterpriseConfigPtrOutput) PrivateKeySecretVersion 

func (o ConnectionGithubEnterpriseConfigPtrOutput) PrivateKeySecretVersion() pulumi.StringPtrOutput

SecretManager resource containing the private key of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.

func (ConnectionGithubEnterpriseConfigPtrOutput) ServiceDirectoryConfig 

func (o ConnectionGithubEnterpriseConfigPtrOutput) ServiceDirectoryConfig() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

Configuration for using Service Directory to privately connect to a GitHub Enterprise server. This should only be set if the GitHub Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitHub Enterprise server will be made over the public internet. Structure is documented below.

func (ConnectionGithubEnterpriseConfigPtrOutput) SslCa 

func (o ConnectionGithubEnterpriseConfigPtrOutput) SslCa() pulumi.StringPtrOutput

SSL certificate to use for requests to GitHub Enterprise.

func (ConnectionGithubEnterpriseConfigPtrOutput) ToConnectionGithubEnterpriseConfigPtrOutput 

func (o ConnectionGithubEnterpriseConfigPtrOutput) ToConnectionGithubEnterpriseConfigPtrOutput() ConnectionGithubEnterpriseConfigPtrOutput

func (ConnectionGithubEnterpriseConfigPtrOutput) ToConnectionGithubEnterpriseConfigPtrOutputWithContext 

func (o ConnectionGithubEnterpriseConfigPtrOutput) ToConnectionGithubEnterpriseConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigPtrOutput

func (ConnectionGithubEnterpriseConfigPtrOutput) WebhookSecretSecretVersion 

func (o ConnectionGithubEnterpriseConfigPtrOutput) WebhookSecretSecretVersion() pulumi.StringPtrOutput

SecretManager resource containing the webhook secret of the GitHub App, formatted as `projects/*/secrets/*/versions/*`.

type ConnectionGithubEnterpriseConfigServiceDirectoryConfig 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfig struct {
	// Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
	Service string `pulumi:"service"`
}

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs struct {
	// Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
	Service pulumi.StringInput `pulumi:"service"`
}

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ElementType 

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput 

func (i ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutputWithContext 

func (i ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput 

func (i ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext 

func (i ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigInput 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigInput interface {
	pulumi.Input

	ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput
	ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutputWithContext(context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput
}

ConnectionGithubEnterpriseConfigServiceDirectoryConfigInput is an input type that accepts ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs and ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput values. You can construct a concrete instance of `ConnectionGithubEnterpriseConfigServiceDirectoryConfigInput` via: 

ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs{...}

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput struct{ *pulumi.OutputState }

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ElementType 

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) Service 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) Service() pulumi.StringOutput

Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutputWithContext 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput interface {
	pulumi.Input

	ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput
	ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext(context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput
}

ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput is an input type that accepts ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs, ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtr and ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput values. You can construct a concrete instance of `ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput` via: 

        ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs{...}

or:

        nil

func ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtr 

func ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtr(v *ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs) ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrInput

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput 

type ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) Elem 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) Elem() ConnectionGithubEnterpriseConfigServiceDirectoryConfigOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ElementType 

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ElementType() reflect.Type

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) Service 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) Service() pulumi.StringPtrOutput

Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput() ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

func (ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext 

func (o ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput) ToConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGithubEnterpriseConfigServiceDirectoryConfigPtrOutput

type ConnectionGitlabConfig 

type ConnectionGitlabConfig struct {
	// Required. A GitLab personal access token with the `api` scope access.
	// Structure is documented below.
	AuthorizerCredential ConnectionGitlabConfigAuthorizerCredential `pulumi:"authorizerCredential"`
	// The URI of the GitLab Enterprise host this connection is for. If not specified, the default value is https://gitlab.com.
	HostUri *string `pulumi:"hostUri"`
	// Required. A GitLab personal access token with the minimum `readApi` scope access.
	// Structure is documented below.
	ReadAuthorizerCredential ConnectionGitlabConfigReadAuthorizerCredential `pulumi:"readAuthorizerCredential"`
	// (Output)
	// Output only. Version of the GitLab Enterprise server running on the `hostUri`.
	ServerVersion *string `pulumi:"serverVersion"`
	// Configuration for using Service Directory to privately connect to a GitLab Enterprise server. This should only be set if the GitLab Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitLab Enterprise server will be made over the public internet.
	// Structure is documented below.
	ServiceDirectoryConfig *ConnectionGitlabConfigServiceDirectoryConfig `pulumi:"serviceDirectoryConfig"`
	// SSL certificate to use for requests to GitLab Enterprise.
	SslCa *string `pulumi:"sslCa"`
	// Required. Immutable. SecretManager resource containing the webhook secret of a GitLab Enterprise project, formatted as `projects/*/secrets/*/versions/*`.
	WebhookSecretSecretVersion string `pulumi:"webhookSecretSecretVersion"`
}

type ConnectionGitlabConfigArgs 

type ConnectionGitlabConfigArgs struct {
	// Required. A GitLab personal access token with the `api` scope access.
	// Structure is documented below.
	AuthorizerCredential ConnectionGitlabConfigAuthorizerCredentialInput `pulumi:"authorizerCredential"`
	// The URI of the GitLab Enterprise host this connection is for. If not specified, the default value is https://gitlab.com.
	HostUri pulumi.StringPtrInput `pulumi:"hostUri"`
	// Required. A GitLab personal access token with the minimum `readApi` scope access.
	// Structure is documented below.
	ReadAuthorizerCredential ConnectionGitlabConfigReadAuthorizerCredentialInput `pulumi:"readAuthorizerCredential"`
	// (Output)
	// Output only. Version of the GitLab Enterprise server running on the `hostUri`.
	ServerVersion pulumi.StringPtrInput `pulumi:"serverVersion"`
	// Configuration for using Service Directory to privately connect to a GitLab Enterprise server. This should only be set if the GitLab Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitLab Enterprise server will be made over the public internet.
	// Structure is documented below.
	ServiceDirectoryConfig ConnectionGitlabConfigServiceDirectoryConfigPtrInput `pulumi:"serviceDirectoryConfig"`
	// SSL certificate to use for requests to GitLab Enterprise.
	SslCa pulumi.StringPtrInput `pulumi:"sslCa"`
	// Required. Immutable. SecretManager resource containing the webhook secret of a GitLab Enterprise project, formatted as `projects/*/secrets/*/versions/*`.
	WebhookSecretSecretVersion pulumi.StringInput `pulumi:"webhookSecretSecretVersion"`
}

func (ConnectionGitlabConfigArgs) ElementType 

func (ConnectionGitlabConfigArgs) ElementType() reflect.Type

func (ConnectionGitlabConfigArgs) ToConnectionGitlabConfigOutput 

func (i ConnectionGitlabConfigArgs) ToConnectionGitlabConfigOutput() ConnectionGitlabConfigOutput

func (ConnectionGitlabConfigArgs) ToConnectionGitlabConfigOutputWithContext 

func (i ConnectionGitlabConfigArgs) ToConnectionGitlabConfigOutputWithContext(ctx context.Context) ConnectionGitlabConfigOutput

func (ConnectionGitlabConfigArgs) ToConnectionGitlabConfigPtrOutput 

func (i ConnectionGitlabConfigArgs) ToConnectionGitlabConfigPtrOutput() ConnectionGitlabConfigPtrOutput

func (ConnectionGitlabConfigArgs) ToConnectionGitlabConfigPtrOutputWithContext 

func (i ConnectionGitlabConfigArgs) ToConnectionGitlabConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigPtrOutput

type ConnectionGitlabConfigAuthorizerCredential 

type ConnectionGitlabConfigAuthorizerCredential struct {
	// Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	UserTokenSecretVersion string `pulumi:"userTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username *string `pulumi:"username"`
}

type ConnectionGitlabConfigAuthorizerCredentialArgs 

type ConnectionGitlabConfigAuthorizerCredentialArgs struct {
	// Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	UserTokenSecretVersion pulumi.StringInput `pulumi:"userTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ElementType 

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ElementType() reflect.Type

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialOutput 

func (i ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialOutput() ConnectionGitlabConfigAuthorizerCredentialOutput

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialOutputWithContext 

func (i ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGitlabConfigAuthorizerCredentialOutput

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput 

func (i ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput() ConnectionGitlabConfigAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext 

func (i ConnectionGitlabConfigAuthorizerCredentialArgs) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigAuthorizerCredentialPtrOutput

type ConnectionGitlabConfigAuthorizerCredentialInput 

type ConnectionGitlabConfigAuthorizerCredentialInput interface {
	pulumi.Input

	ToConnectionGitlabConfigAuthorizerCredentialOutput() ConnectionGitlabConfigAuthorizerCredentialOutput
	ToConnectionGitlabConfigAuthorizerCredentialOutputWithContext(context.Context) ConnectionGitlabConfigAuthorizerCredentialOutput
}

ConnectionGitlabConfigAuthorizerCredentialInput is an input type that accepts ConnectionGitlabConfigAuthorizerCredentialArgs and ConnectionGitlabConfigAuthorizerCredentialOutput values. You can construct a concrete instance of `ConnectionGitlabConfigAuthorizerCredentialInput` via: 

ConnectionGitlabConfigAuthorizerCredentialArgs{...}

type ConnectionGitlabConfigAuthorizerCredentialOutput 

type ConnectionGitlabConfigAuthorizerCredentialOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ElementType 

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialOutput 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialOutput() ConnectionGitlabConfigAuthorizerCredentialOutput

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialOutputWithContext 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGitlabConfigAuthorizerCredentialOutput

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput() ConnectionGitlabConfigAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigAuthorizerCredentialOutput) UserTokenSecretVersion 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) UserTokenSecretVersion() pulumi.StringOutput

Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGitlabConfigAuthorizerCredentialOutput) Username 

func (o ConnectionGitlabConfigAuthorizerCredentialOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGitlabConfigAuthorizerCredentialPtrInput 

type ConnectionGitlabConfigAuthorizerCredentialPtrInput interface {
	pulumi.Input

	ToConnectionGitlabConfigAuthorizerCredentialPtrOutput() ConnectionGitlabConfigAuthorizerCredentialPtrOutput
	ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext(context.Context) ConnectionGitlabConfigAuthorizerCredentialPtrOutput
}

ConnectionGitlabConfigAuthorizerCredentialPtrInput is an input type that accepts ConnectionGitlabConfigAuthorizerCredentialArgs, ConnectionGitlabConfigAuthorizerCredentialPtr and ConnectionGitlabConfigAuthorizerCredentialPtrOutput values. You can construct a concrete instance of `ConnectionGitlabConfigAuthorizerCredentialPtrInput` via: 

        ConnectionGitlabConfigAuthorizerCredentialArgs{...}

or:

        nil

func ConnectionGitlabConfigAuthorizerCredentialPtr 

func ConnectionGitlabConfigAuthorizerCredentialPtr(v *ConnectionGitlabConfigAuthorizerCredentialArgs) ConnectionGitlabConfigAuthorizerCredentialPtrInput

type ConnectionGitlabConfigAuthorizerCredentialPtrOutput 

type ConnectionGitlabConfigAuthorizerCredentialPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) Elem 

func (o ConnectionGitlabConfigAuthorizerCredentialPtrOutput) Elem() ConnectionGitlabConfigAuthorizerCredentialOutput

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ElementType 

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput 

func (o ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutput() ConnectionGitlabConfigAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGitlabConfigAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) UserTokenSecretVersion 

func (o ConnectionGitlabConfigAuthorizerCredentialPtrOutput) UserTokenSecretVersion() pulumi.StringPtrOutput

Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGitlabConfigAuthorizerCredentialPtrOutput) Username 

func (o ConnectionGitlabConfigAuthorizerCredentialPtrOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGitlabConfigInput 

type ConnectionGitlabConfigInput interface {
	pulumi.Input

	ToConnectionGitlabConfigOutput() ConnectionGitlabConfigOutput
	ToConnectionGitlabConfigOutputWithContext(context.Context) ConnectionGitlabConfigOutput
}

ConnectionGitlabConfigInput is an input type that accepts ConnectionGitlabConfigArgs and ConnectionGitlabConfigOutput values. You can construct a concrete instance of `ConnectionGitlabConfigInput` via: 

ConnectionGitlabConfigArgs{...}

type ConnectionGitlabConfigOutput 

type ConnectionGitlabConfigOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigOutput) AuthorizerCredential 

func (o ConnectionGitlabConfigOutput) AuthorizerCredential() ConnectionGitlabConfigAuthorizerCredentialOutput

Required. A GitLab personal access token with the `api` scope access. Structure is documented below.

func (ConnectionGitlabConfigOutput) ElementType 

func (ConnectionGitlabConfigOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigOutput) HostUri 

func (o ConnectionGitlabConfigOutput) HostUri() pulumi.StringPtrOutput

The URI of the GitLab Enterprise host this connection is for. If not specified, the default value is https://gitlab.com.

func (ConnectionGitlabConfigOutput) ReadAuthorizerCredential 

func (o ConnectionGitlabConfigOutput) ReadAuthorizerCredential() ConnectionGitlabConfigReadAuthorizerCredentialOutput

Required. A GitLab personal access token with the minimum `readApi` scope access. Structure is documented below.

func (ConnectionGitlabConfigOutput) ServerVersion 

func (o ConnectionGitlabConfigOutput) ServerVersion() pulumi.StringPtrOutput

(Output) Output only. Version of the GitLab Enterprise server running on the `hostUri`.

func (ConnectionGitlabConfigOutput) ServiceDirectoryConfig 

func (o ConnectionGitlabConfigOutput) ServiceDirectoryConfig() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

Configuration for using Service Directory to privately connect to a GitLab Enterprise server. This should only be set if the GitLab Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitLab Enterprise server will be made over the public internet. Structure is documented below.

func (ConnectionGitlabConfigOutput) SslCa 

func (o ConnectionGitlabConfigOutput) SslCa() pulumi.StringPtrOutput

SSL certificate to use for requests to GitLab Enterprise.

func (ConnectionGitlabConfigOutput) ToConnectionGitlabConfigOutput 

func (o ConnectionGitlabConfigOutput) ToConnectionGitlabConfigOutput() ConnectionGitlabConfigOutput

func (ConnectionGitlabConfigOutput) ToConnectionGitlabConfigOutputWithContext 

func (o ConnectionGitlabConfigOutput) ToConnectionGitlabConfigOutputWithContext(ctx context.Context) ConnectionGitlabConfigOutput

func (ConnectionGitlabConfigOutput) ToConnectionGitlabConfigPtrOutput 

func (o ConnectionGitlabConfigOutput) ToConnectionGitlabConfigPtrOutput() ConnectionGitlabConfigPtrOutput

func (ConnectionGitlabConfigOutput) ToConnectionGitlabConfigPtrOutputWithContext 

func (o ConnectionGitlabConfigOutput) ToConnectionGitlabConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigPtrOutput

func (ConnectionGitlabConfigOutput) WebhookSecretSecretVersion 

func (o ConnectionGitlabConfigOutput) WebhookSecretSecretVersion() pulumi.StringOutput

Required. Immutable. SecretManager resource containing the webhook secret of a GitLab Enterprise project, formatted as `projects/*/secrets/*/versions/*`.

type ConnectionGitlabConfigPtrInput 

type ConnectionGitlabConfigPtrInput interface {
	pulumi.Input

	ToConnectionGitlabConfigPtrOutput() ConnectionGitlabConfigPtrOutput
	ToConnectionGitlabConfigPtrOutputWithContext(context.Context) ConnectionGitlabConfigPtrOutput
}

ConnectionGitlabConfigPtrInput is an input type that accepts ConnectionGitlabConfigArgs, ConnectionGitlabConfigPtr and ConnectionGitlabConfigPtrOutput values. You can construct a concrete instance of `ConnectionGitlabConfigPtrInput` via: 

        ConnectionGitlabConfigArgs{...}

or:

        nil

func ConnectionGitlabConfigPtr 

func ConnectionGitlabConfigPtr(v *ConnectionGitlabConfigArgs) ConnectionGitlabConfigPtrInput

type ConnectionGitlabConfigPtrOutput 

type ConnectionGitlabConfigPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigPtrOutput) AuthorizerCredential 

func (o ConnectionGitlabConfigPtrOutput) AuthorizerCredential() ConnectionGitlabConfigAuthorizerCredentialPtrOutput

Required. A GitLab personal access token with the `api` scope access. Structure is documented below.

func (ConnectionGitlabConfigPtrOutput) Elem 

func (o ConnectionGitlabConfigPtrOutput) Elem() ConnectionGitlabConfigOutput

func (ConnectionGitlabConfigPtrOutput) ElementType 

func (ConnectionGitlabConfigPtrOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigPtrOutput) HostUri 

func (o ConnectionGitlabConfigPtrOutput) HostUri() pulumi.StringPtrOutput

The URI of the GitLab Enterprise host this connection is for. If not specified, the default value is https://gitlab.com.

func (ConnectionGitlabConfigPtrOutput) ReadAuthorizerCredential 

func (o ConnectionGitlabConfigPtrOutput) ReadAuthorizerCredential() ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

Required. A GitLab personal access token with the minimum `readApi` scope access. Structure is documented below.

func (ConnectionGitlabConfigPtrOutput) ServerVersion 

func (o ConnectionGitlabConfigPtrOutput) ServerVersion() pulumi.StringPtrOutput

(Output) Output only. Version of the GitLab Enterprise server running on the `hostUri`.

func (ConnectionGitlabConfigPtrOutput) ServiceDirectoryConfig 

func (o ConnectionGitlabConfigPtrOutput) ServiceDirectoryConfig() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

Configuration for using Service Directory to privately connect to a GitLab Enterprise server. This should only be set if the GitLab Enterprise server is hosted on-premises and not reachable by public internet. If this field is left empty, calls to the GitLab Enterprise server will be made over the public internet. Structure is documented below.

func (ConnectionGitlabConfigPtrOutput) SslCa 

func (o ConnectionGitlabConfigPtrOutput) SslCa() pulumi.StringPtrOutput

SSL certificate to use for requests to GitLab Enterprise.

func (ConnectionGitlabConfigPtrOutput) ToConnectionGitlabConfigPtrOutput 

func (o ConnectionGitlabConfigPtrOutput) ToConnectionGitlabConfigPtrOutput() ConnectionGitlabConfigPtrOutput

func (ConnectionGitlabConfigPtrOutput) ToConnectionGitlabConfigPtrOutputWithContext 

func (o ConnectionGitlabConfigPtrOutput) ToConnectionGitlabConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigPtrOutput

func (ConnectionGitlabConfigPtrOutput) WebhookSecretSecretVersion 

func (o ConnectionGitlabConfigPtrOutput) WebhookSecretSecretVersion() pulumi.StringPtrOutput

Required. Immutable. SecretManager resource containing the webhook secret of a GitLab Enterprise project, formatted as `projects/*/secrets/*/versions/*`.

type ConnectionGitlabConfigReadAuthorizerCredential 

type ConnectionGitlabConfigReadAuthorizerCredential struct {
	// Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	UserTokenSecretVersion string `pulumi:"userTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username *string `pulumi:"username"`
}

type ConnectionGitlabConfigReadAuthorizerCredentialArgs 

type ConnectionGitlabConfigReadAuthorizerCredentialArgs struct {
	// Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.
	UserTokenSecretVersion pulumi.StringInput `pulumi:"userTokenSecretVersion"`
	// (Output)
	// Output only. The username associated to this token.
	Username pulumi.StringPtrInput `pulumi:"username"`
}

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ElementType 

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ElementType() reflect.Type

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialOutput 

func (i ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialOutput() ConnectionGitlabConfigReadAuthorizerCredentialOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialOutputWithContext 

func (i ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGitlabConfigReadAuthorizerCredentialOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput 

func (i ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput() ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext 

func (i ConnectionGitlabConfigReadAuthorizerCredentialArgs) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

type ConnectionGitlabConfigReadAuthorizerCredentialInput 

type ConnectionGitlabConfigReadAuthorizerCredentialInput interface {
	pulumi.Input

	ToConnectionGitlabConfigReadAuthorizerCredentialOutput() ConnectionGitlabConfigReadAuthorizerCredentialOutput
	ToConnectionGitlabConfigReadAuthorizerCredentialOutputWithContext(context.Context) ConnectionGitlabConfigReadAuthorizerCredentialOutput
}

ConnectionGitlabConfigReadAuthorizerCredentialInput is an input type that accepts ConnectionGitlabConfigReadAuthorizerCredentialArgs and ConnectionGitlabConfigReadAuthorizerCredentialOutput values. You can construct a concrete instance of `ConnectionGitlabConfigReadAuthorizerCredentialInput` via: 

ConnectionGitlabConfigReadAuthorizerCredentialArgs{...}

type ConnectionGitlabConfigReadAuthorizerCredentialOutput 

type ConnectionGitlabConfigReadAuthorizerCredentialOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ElementType 

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialOutput 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialOutput() ConnectionGitlabConfigReadAuthorizerCredentialOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialOutputWithContext 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialOutputWithContext(ctx context.Context) ConnectionGitlabConfigReadAuthorizerCredentialOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput() ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) UserTokenSecretVersion 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) UserTokenSecretVersion() pulumi.StringOutput

Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGitlabConfigReadAuthorizerCredentialOutput) Username 

func (o ConnectionGitlabConfigReadAuthorizerCredentialOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGitlabConfigReadAuthorizerCredentialPtrInput 

type ConnectionGitlabConfigReadAuthorizerCredentialPtrInput interface {
	pulumi.Input

	ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput() ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput
	ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext(context.Context) ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput
}

ConnectionGitlabConfigReadAuthorizerCredentialPtrInput is an input type that accepts ConnectionGitlabConfigReadAuthorizerCredentialArgs, ConnectionGitlabConfigReadAuthorizerCredentialPtr and ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput values. You can construct a concrete instance of `ConnectionGitlabConfigReadAuthorizerCredentialPtrInput` via: 

        ConnectionGitlabConfigReadAuthorizerCredentialArgs{...}

or:

        nil

func ConnectionGitlabConfigReadAuthorizerCredentialPtr 

func ConnectionGitlabConfigReadAuthorizerCredentialPtr(v *ConnectionGitlabConfigReadAuthorizerCredentialArgs) ConnectionGitlabConfigReadAuthorizerCredentialPtrInput

type ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput 

type ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) Elem 

func (o ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) Elem() ConnectionGitlabConfigReadAuthorizerCredentialOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ElementType 

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput 

func (o ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutput() ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext 

func (o ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) ToConnectionGitlabConfigReadAuthorizerCredentialPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) UserTokenSecretVersion 

func (o ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) UserTokenSecretVersion() pulumi.StringPtrOutput

Required. A SecretManager resource containing the user token that authorizes the Cloud Build connection. Format: `projects/*/secrets/*/versions/*`.

func (ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) Username 

func (o ConnectionGitlabConfigReadAuthorizerCredentialPtrOutput) Username() pulumi.StringPtrOutput

(Output) Output only. The username associated to this token.

type ConnectionGitlabConfigServiceDirectoryConfig 

type ConnectionGitlabConfigServiceDirectoryConfig struct {
	// Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
	Service string `pulumi:"service"`
}

type ConnectionGitlabConfigServiceDirectoryConfigArgs 

type ConnectionGitlabConfigServiceDirectoryConfigArgs struct {
	// Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
	Service pulumi.StringInput `pulumi:"service"`
}

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ElementType 

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ElementType() reflect.Type

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigOutput 

func (i ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigOutput() ConnectionGitlabConfigServiceDirectoryConfigOutput

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigOutputWithContext 

func (i ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigOutputWithContext(ctx context.Context) ConnectionGitlabConfigServiceDirectoryConfigOutput

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput 

func (i ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

func (ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext 

func (i ConnectionGitlabConfigServiceDirectoryConfigArgs) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

type ConnectionGitlabConfigServiceDirectoryConfigInput 

type ConnectionGitlabConfigServiceDirectoryConfigInput interface {
	pulumi.Input

	ToConnectionGitlabConfigServiceDirectoryConfigOutput() ConnectionGitlabConfigServiceDirectoryConfigOutput
	ToConnectionGitlabConfigServiceDirectoryConfigOutputWithContext(context.Context) ConnectionGitlabConfigServiceDirectoryConfigOutput
}

ConnectionGitlabConfigServiceDirectoryConfigInput is an input type that accepts ConnectionGitlabConfigServiceDirectoryConfigArgs and ConnectionGitlabConfigServiceDirectoryConfigOutput values. You can construct a concrete instance of `ConnectionGitlabConfigServiceDirectoryConfigInput` via: 

ConnectionGitlabConfigServiceDirectoryConfigArgs{...}

type ConnectionGitlabConfigServiceDirectoryConfigOutput 

type ConnectionGitlabConfigServiceDirectoryConfigOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ElementType 

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) Service 

func (o ConnectionGitlabConfigServiceDirectoryConfigOutput) Service() pulumi.StringOutput

Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigOutput 

func (o ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigOutput() ConnectionGitlabConfigServiceDirectoryConfigOutput

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigOutputWithContext 

func (o ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigOutputWithContext(ctx context.Context) ConnectionGitlabConfigServiceDirectoryConfigOutput

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput 

func (o ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

func (ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext 

func (o ConnectionGitlabConfigServiceDirectoryConfigOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

type ConnectionGitlabConfigServiceDirectoryConfigPtrInput 

type ConnectionGitlabConfigServiceDirectoryConfigPtrInput interface {
	pulumi.Input

	ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput
	ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext(context.Context) ConnectionGitlabConfigServiceDirectoryConfigPtrOutput
}

ConnectionGitlabConfigServiceDirectoryConfigPtrInput is an input type that accepts ConnectionGitlabConfigServiceDirectoryConfigArgs, ConnectionGitlabConfigServiceDirectoryConfigPtr and ConnectionGitlabConfigServiceDirectoryConfigPtrOutput values. You can construct a concrete instance of `ConnectionGitlabConfigServiceDirectoryConfigPtrInput` via: 

        ConnectionGitlabConfigServiceDirectoryConfigArgs{...}

or:

        nil

func ConnectionGitlabConfigServiceDirectoryConfigPtr 

func ConnectionGitlabConfigServiceDirectoryConfigPtr(v *ConnectionGitlabConfigServiceDirectoryConfigArgs) ConnectionGitlabConfigServiceDirectoryConfigPtrInput

type ConnectionGitlabConfigServiceDirectoryConfigPtrOutput 

type ConnectionGitlabConfigServiceDirectoryConfigPtrOutput struct{ *pulumi.OutputState }

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) Elem 

func (o ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) Elem() ConnectionGitlabConfigServiceDirectoryConfigOutput

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ElementType 

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ElementType() reflect.Type

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) Service 

func (o ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) Service() pulumi.StringPtrOutput

Required. The Service Directory service name. Format: projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput 

func (o ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutput() ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

func (ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext 

func (o ConnectionGitlabConfigServiceDirectoryConfigPtrOutput) ToConnectionGitlabConfigServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ConnectionGitlabConfigServiceDirectoryConfigPtrOutput

type ConnectionIAMBinding 

type ConnectionIAMBinding struct {
	pulumi.CustomResourceState

	Condition ConnectionIAMBindingConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Cloud Build v2 Connection. Each of these resources serves a different use case:

* `cloudbuildv2.ConnectionIAMPolicy`: Authoritative. Sets the IAM policy for the connection and replaces any existing policy already attached. * `cloudbuildv2.ConnectionIAMBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the connection are preserved. * `cloudbuildv2.ConnectionIAMMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the connection are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `cloudbuildv2.ConnectionIAMPolicy`: Retrieves the IAM policy for the connection

> **Note:** `cloudbuildv2.ConnectionIAMPolicy` **cannot** be used in conjunction with `cloudbuildv2.ConnectionIAMBinding` and `cloudbuildv2.ConnectionIAMMember` or they will fight over what your policy should be.

> **Note:** `cloudbuildv2.ConnectionIAMBinding` resources **can be** used in conjunction with `cloudbuildv2.ConnectionIAMMember` resources **only if** they do not grant privilege to the same role.

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/connections/{{name}}

* {{project}}/{{location}}/{{name}}

* {{location}}/{{name}}

* {{name}}

Any variables not passed in the import command will be taken from the provider configuration.

Cloud Build v2 connection IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMBinding:ConnectionIAMBinding editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMBinding:ConnectionIAMBinding editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMBinding:ConnectionIAMBinding editor projects/{{project}}/locations/{{location}}/connections/{{connection}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetConnectionIAMBinding 

func GetConnectionIAMBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectionIAMBindingState, opts ...pulumi.ResourceOption) (*ConnectionIAMBinding, error)

GetConnectionIAMBinding gets an existing ConnectionIAMBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConnectionIAMBinding 

func NewConnectionIAMBinding(ctx *pulumi.Context,
	name string, args *ConnectionIAMBindingArgs, opts ...pulumi.ResourceOption) (*ConnectionIAMBinding, error)

NewConnectionIAMBinding registers a new resource with the given unique name, arguments, and options.

func (*ConnectionIAMBinding) ElementType 

func (*ConnectionIAMBinding) ElementType() reflect.Type

func (*ConnectionIAMBinding) ToConnectionIAMBindingOutput 

func (i *ConnectionIAMBinding) ToConnectionIAMBindingOutput() ConnectionIAMBindingOutput

func (*ConnectionIAMBinding) ToConnectionIAMBindingOutputWithContext 

func (i *ConnectionIAMBinding) ToConnectionIAMBindingOutputWithContext(ctx context.Context) ConnectionIAMBindingOutput

type ConnectionIAMBindingArgs 

type ConnectionIAMBindingArgs struct {
	Condition ConnectionIAMBindingConditionPtrInput
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ConnectionIAMBinding resource.

func (ConnectionIAMBindingArgs) ElementType 

func (ConnectionIAMBindingArgs) ElementType() reflect.Type

type ConnectionIAMBindingArray 

type ConnectionIAMBindingArray []ConnectionIAMBindingInput

func (ConnectionIAMBindingArray) ElementType 

func (ConnectionIAMBindingArray) ElementType() reflect.Type

func (ConnectionIAMBindingArray) ToConnectionIAMBindingArrayOutput 

func (i ConnectionIAMBindingArray) ToConnectionIAMBindingArrayOutput() ConnectionIAMBindingArrayOutput

func (ConnectionIAMBindingArray) ToConnectionIAMBindingArrayOutputWithContext 

func (i ConnectionIAMBindingArray) ToConnectionIAMBindingArrayOutputWithContext(ctx context.Context) ConnectionIAMBindingArrayOutput

type ConnectionIAMBindingArrayInput 

type ConnectionIAMBindingArrayInput interface {
	pulumi.Input

	ToConnectionIAMBindingArrayOutput() ConnectionIAMBindingArrayOutput
	ToConnectionIAMBindingArrayOutputWithContext(context.Context) ConnectionIAMBindingArrayOutput
}

ConnectionIAMBindingArrayInput is an input type that accepts ConnectionIAMBindingArray and ConnectionIAMBindingArrayOutput values. You can construct a concrete instance of `ConnectionIAMBindingArrayInput` via: 

ConnectionIAMBindingArray{ ConnectionIAMBindingArgs{...} }

type ConnectionIAMBindingArrayOutput 

type ConnectionIAMBindingArrayOutput struct{ *pulumi.OutputState }

func (ConnectionIAMBindingArrayOutput) ElementType 

func (ConnectionIAMBindingArrayOutput) ElementType() reflect.Type

func (ConnectionIAMBindingArrayOutput) Index 

func (o ConnectionIAMBindingArrayOutput) Index(i pulumi.IntInput) ConnectionIAMBindingOutput

func (ConnectionIAMBindingArrayOutput) ToConnectionIAMBindingArrayOutput 

func (o ConnectionIAMBindingArrayOutput) ToConnectionIAMBindingArrayOutput() ConnectionIAMBindingArrayOutput

func (ConnectionIAMBindingArrayOutput) ToConnectionIAMBindingArrayOutputWithContext 

func (o ConnectionIAMBindingArrayOutput) ToConnectionIAMBindingArrayOutputWithContext(ctx context.Context) ConnectionIAMBindingArrayOutput

type ConnectionIAMBindingCondition 

type ConnectionIAMBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ConnectionIAMBindingConditionArgs 

type ConnectionIAMBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ConnectionIAMBindingConditionArgs) ElementType 

func (ConnectionIAMBindingConditionArgs) ElementType() reflect.Type

func (ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionOutput 

func (i ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionOutput() ConnectionIAMBindingConditionOutput

func (ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionOutputWithContext 

func (i ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionOutputWithContext(ctx context.Context) ConnectionIAMBindingConditionOutput

func (ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionPtrOutput 

func (i ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionPtrOutput() ConnectionIAMBindingConditionPtrOutput

func (ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionPtrOutputWithContext 

func (i ConnectionIAMBindingConditionArgs) ToConnectionIAMBindingConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMBindingConditionPtrOutput

type ConnectionIAMBindingConditionInput 

type ConnectionIAMBindingConditionInput interface {
	pulumi.Input

	ToConnectionIAMBindingConditionOutput() ConnectionIAMBindingConditionOutput
	ToConnectionIAMBindingConditionOutputWithContext(context.Context) ConnectionIAMBindingConditionOutput
}

ConnectionIAMBindingConditionInput is an input type that accepts ConnectionIAMBindingConditionArgs and ConnectionIAMBindingConditionOutput values. You can construct a concrete instance of `ConnectionIAMBindingConditionInput` via: 

ConnectionIAMBindingConditionArgs{...}

type ConnectionIAMBindingConditionOutput 

type ConnectionIAMBindingConditionOutput struct{ *pulumi.OutputState }

func (ConnectionIAMBindingConditionOutput) Description 

func (o ConnectionIAMBindingConditionOutput) Description() pulumi.StringPtrOutput

func (ConnectionIAMBindingConditionOutput) ElementType 

func (ConnectionIAMBindingConditionOutput) ElementType() reflect.Type

func (ConnectionIAMBindingConditionOutput) Expression 

func (o ConnectionIAMBindingConditionOutput) Expression() pulumi.StringOutput

func (ConnectionIAMBindingConditionOutput) Title 

func (o ConnectionIAMBindingConditionOutput) Title() pulumi.StringOutput

func (ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionOutput 

func (o ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionOutput() ConnectionIAMBindingConditionOutput

func (ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionOutputWithContext 

func (o ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionOutputWithContext(ctx context.Context) ConnectionIAMBindingConditionOutput

func (ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionPtrOutput 

func (o ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionPtrOutput() ConnectionIAMBindingConditionPtrOutput

func (ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionPtrOutputWithContext 

func (o ConnectionIAMBindingConditionOutput) ToConnectionIAMBindingConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMBindingConditionPtrOutput

type ConnectionIAMBindingConditionPtrInput 

type ConnectionIAMBindingConditionPtrInput interface {
	pulumi.Input

	ToConnectionIAMBindingConditionPtrOutput() ConnectionIAMBindingConditionPtrOutput
	ToConnectionIAMBindingConditionPtrOutputWithContext(context.Context) ConnectionIAMBindingConditionPtrOutput
}

ConnectionIAMBindingConditionPtrInput is an input type that accepts ConnectionIAMBindingConditionArgs, ConnectionIAMBindingConditionPtr and ConnectionIAMBindingConditionPtrOutput values. You can construct a concrete instance of `ConnectionIAMBindingConditionPtrInput` via: 

        ConnectionIAMBindingConditionArgs{...}

or:

        nil

func ConnectionIAMBindingConditionPtr 

func ConnectionIAMBindingConditionPtr(v *ConnectionIAMBindingConditionArgs) ConnectionIAMBindingConditionPtrInput

type ConnectionIAMBindingConditionPtrOutput 

type ConnectionIAMBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (ConnectionIAMBindingConditionPtrOutput) Description 

func (o ConnectionIAMBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ConnectionIAMBindingConditionPtrOutput) Elem 

func (o ConnectionIAMBindingConditionPtrOutput) Elem() ConnectionIAMBindingConditionOutput

func (ConnectionIAMBindingConditionPtrOutput) ElementType 

func (ConnectionIAMBindingConditionPtrOutput) ElementType() reflect.Type

func (ConnectionIAMBindingConditionPtrOutput) Expression 

func (o ConnectionIAMBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ConnectionIAMBindingConditionPtrOutput) Title 

func (o ConnectionIAMBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ConnectionIAMBindingConditionPtrOutput) ToConnectionIAMBindingConditionPtrOutput 

func (o ConnectionIAMBindingConditionPtrOutput) ToConnectionIAMBindingConditionPtrOutput() ConnectionIAMBindingConditionPtrOutput

func (ConnectionIAMBindingConditionPtrOutput) ToConnectionIAMBindingConditionPtrOutputWithContext 

func (o ConnectionIAMBindingConditionPtrOutput) ToConnectionIAMBindingConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMBindingConditionPtrOutput

type ConnectionIAMBindingInput 

type ConnectionIAMBindingInput interface {
	pulumi.Input

	ToConnectionIAMBindingOutput() ConnectionIAMBindingOutput
	ToConnectionIAMBindingOutputWithContext(ctx context.Context) ConnectionIAMBindingOutput
}

type ConnectionIAMBindingMap 

type ConnectionIAMBindingMap map[string]ConnectionIAMBindingInput

func (ConnectionIAMBindingMap) ElementType 

func (ConnectionIAMBindingMap) ElementType() reflect.Type

func (ConnectionIAMBindingMap) ToConnectionIAMBindingMapOutput 

func (i ConnectionIAMBindingMap) ToConnectionIAMBindingMapOutput() ConnectionIAMBindingMapOutput

func (ConnectionIAMBindingMap) ToConnectionIAMBindingMapOutputWithContext 

func (i ConnectionIAMBindingMap) ToConnectionIAMBindingMapOutputWithContext(ctx context.Context) ConnectionIAMBindingMapOutput

type ConnectionIAMBindingMapInput 

type ConnectionIAMBindingMapInput interface {
	pulumi.Input

	ToConnectionIAMBindingMapOutput() ConnectionIAMBindingMapOutput
	ToConnectionIAMBindingMapOutputWithContext(context.Context) ConnectionIAMBindingMapOutput
}

ConnectionIAMBindingMapInput is an input type that accepts ConnectionIAMBindingMap and ConnectionIAMBindingMapOutput values. You can construct a concrete instance of `ConnectionIAMBindingMapInput` via: 

ConnectionIAMBindingMap{ "key": ConnectionIAMBindingArgs{...} }

type ConnectionIAMBindingMapOutput 

type ConnectionIAMBindingMapOutput struct{ *pulumi.OutputState }

func (ConnectionIAMBindingMapOutput) ElementType 

func (ConnectionIAMBindingMapOutput) ElementType() reflect.Type

func (ConnectionIAMBindingMapOutput) MapIndex 

func (o ConnectionIAMBindingMapOutput) MapIndex(k pulumi.StringInput) ConnectionIAMBindingOutput

func (ConnectionIAMBindingMapOutput) ToConnectionIAMBindingMapOutput 

func (o ConnectionIAMBindingMapOutput) ToConnectionIAMBindingMapOutput() ConnectionIAMBindingMapOutput

func (ConnectionIAMBindingMapOutput) ToConnectionIAMBindingMapOutputWithContext 

func (o ConnectionIAMBindingMapOutput) ToConnectionIAMBindingMapOutputWithContext(ctx context.Context) ConnectionIAMBindingMapOutput

type ConnectionIAMBindingOutput 

type ConnectionIAMBindingOutput struct{ *pulumi.OutputState }

func (ConnectionIAMBindingOutput) Condition 

func (o ConnectionIAMBindingOutput) Condition() ConnectionIAMBindingConditionPtrOutput

func (ConnectionIAMBindingOutput) ElementType 

func (ConnectionIAMBindingOutput) ElementType() reflect.Type

func (ConnectionIAMBindingOutput) Etag 

func (o ConnectionIAMBindingOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ConnectionIAMBindingOutput) Location 

func (o ConnectionIAMBindingOutput) Location() pulumi.StringOutput

The location for the resource Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMBindingOutput) Members 

func (o ConnectionIAMBindingOutput) Members() pulumi.StringArrayOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (ConnectionIAMBindingOutput) Name 

func (o ConnectionIAMBindingOutput) Name() pulumi.StringOutput

Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMBindingOutput) Project 

func (o ConnectionIAMBindingOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ConnectionIAMBindingOutput) Role 

func (o ConnectionIAMBindingOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (ConnectionIAMBindingOutput) ToConnectionIAMBindingOutput 

func (o ConnectionIAMBindingOutput) ToConnectionIAMBindingOutput() ConnectionIAMBindingOutput

func (ConnectionIAMBindingOutput) ToConnectionIAMBindingOutputWithContext 

func (o ConnectionIAMBindingOutput) ToConnectionIAMBindingOutputWithContext(ctx context.Context) ConnectionIAMBindingOutput

type ConnectionIAMBindingState 

type ConnectionIAMBindingState struct {
	Condition ConnectionIAMBindingConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ConnectionIAMBindingState) ElementType 

func (ConnectionIAMBindingState) ElementType() reflect.Type

type ConnectionIAMMember 

type ConnectionIAMMember struct {
	pulumi.CustomResourceState

	Condition ConnectionIAMMemberConditionPtrOutput `pulumi:"condition"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringOutput `pulumi:"member"`
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Cloud Build v2 Connection. Each of these resources serves a different use case:

* `cloudbuildv2.ConnectionIAMPolicy`: Authoritative. Sets the IAM policy for the connection and replaces any existing policy already attached. * `cloudbuildv2.ConnectionIAMBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the connection are preserved. * `cloudbuildv2.ConnectionIAMMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the connection are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `cloudbuildv2.ConnectionIAMPolicy`: Retrieves the IAM policy for the connection

> **Note:** `cloudbuildv2.ConnectionIAMPolicy` **cannot** be used in conjunction with `cloudbuildv2.ConnectionIAMBinding` and `cloudbuildv2.ConnectionIAMMember` or they will fight over what your policy should be.

> **Note:** `cloudbuildv2.ConnectionIAMBinding` resources **can be** used in conjunction with `cloudbuildv2.ConnectionIAMMember` resources **only if** they do not grant privilege to the same role.

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/connections/{{name}}

* {{project}}/{{location}}/{{name}}

* {{location}}/{{name}}

* {{name}}

Any variables not passed in the import command will be taken from the provider configuration.

Cloud Build v2 connection IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMMember:ConnectionIAMMember editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMMember:ConnectionIAMMember editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMMember:ConnectionIAMMember editor projects/{{project}}/locations/{{location}}/connections/{{connection}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetConnectionIAMMember 

func GetConnectionIAMMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectionIAMMemberState, opts ...pulumi.ResourceOption) (*ConnectionIAMMember, error)

GetConnectionIAMMember gets an existing ConnectionIAMMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConnectionIAMMember 

func NewConnectionIAMMember(ctx *pulumi.Context,
	name string, args *ConnectionIAMMemberArgs, opts ...pulumi.ResourceOption) (*ConnectionIAMMember, error)

NewConnectionIAMMember registers a new resource with the given unique name, arguments, and options.

func (*ConnectionIAMMember) ElementType 

func (*ConnectionIAMMember) ElementType() reflect.Type

func (*ConnectionIAMMember) ToConnectionIAMMemberOutput 

func (i *ConnectionIAMMember) ToConnectionIAMMemberOutput() ConnectionIAMMemberOutput

func (*ConnectionIAMMember) ToConnectionIAMMemberOutputWithContext 

func (i *ConnectionIAMMember) ToConnectionIAMMemberOutputWithContext(ctx context.Context) ConnectionIAMMemberOutput

type ConnectionIAMMemberArgs 

type ConnectionIAMMemberArgs struct {
	Condition ConnectionIAMMemberConditionPtrInput
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ConnectionIAMMember resource.

func (ConnectionIAMMemberArgs) ElementType 

func (ConnectionIAMMemberArgs) ElementType() reflect.Type

type ConnectionIAMMemberArray 

type ConnectionIAMMemberArray []ConnectionIAMMemberInput

func (ConnectionIAMMemberArray) ElementType 

func (ConnectionIAMMemberArray) ElementType() reflect.Type

func (ConnectionIAMMemberArray) ToConnectionIAMMemberArrayOutput 

func (i ConnectionIAMMemberArray) ToConnectionIAMMemberArrayOutput() ConnectionIAMMemberArrayOutput

func (ConnectionIAMMemberArray) ToConnectionIAMMemberArrayOutputWithContext 

func (i ConnectionIAMMemberArray) ToConnectionIAMMemberArrayOutputWithContext(ctx context.Context) ConnectionIAMMemberArrayOutput

type ConnectionIAMMemberArrayInput 

type ConnectionIAMMemberArrayInput interface {
	pulumi.Input

	ToConnectionIAMMemberArrayOutput() ConnectionIAMMemberArrayOutput
	ToConnectionIAMMemberArrayOutputWithContext(context.Context) ConnectionIAMMemberArrayOutput
}

ConnectionIAMMemberArrayInput is an input type that accepts ConnectionIAMMemberArray and ConnectionIAMMemberArrayOutput values. You can construct a concrete instance of `ConnectionIAMMemberArrayInput` via: 

ConnectionIAMMemberArray{ ConnectionIAMMemberArgs{...} }

type ConnectionIAMMemberArrayOutput 

type ConnectionIAMMemberArrayOutput struct{ *pulumi.OutputState }

func (ConnectionIAMMemberArrayOutput) ElementType 

func (ConnectionIAMMemberArrayOutput) ElementType() reflect.Type

func (ConnectionIAMMemberArrayOutput) Index 

func (o ConnectionIAMMemberArrayOutput) Index(i pulumi.IntInput) ConnectionIAMMemberOutput

func (ConnectionIAMMemberArrayOutput) ToConnectionIAMMemberArrayOutput 

func (o ConnectionIAMMemberArrayOutput) ToConnectionIAMMemberArrayOutput() ConnectionIAMMemberArrayOutput

func (ConnectionIAMMemberArrayOutput) ToConnectionIAMMemberArrayOutputWithContext 

func (o ConnectionIAMMemberArrayOutput) ToConnectionIAMMemberArrayOutputWithContext(ctx context.Context) ConnectionIAMMemberArrayOutput

type ConnectionIAMMemberCondition 

type ConnectionIAMMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ConnectionIAMMemberConditionArgs 

type ConnectionIAMMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ConnectionIAMMemberConditionArgs) ElementType 

func (ConnectionIAMMemberConditionArgs) ElementType() reflect.Type

func (ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionOutput 

func (i ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionOutput() ConnectionIAMMemberConditionOutput

func (ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionOutputWithContext 

func (i ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionOutputWithContext(ctx context.Context) ConnectionIAMMemberConditionOutput

func (ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionPtrOutput 

func (i ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionPtrOutput() ConnectionIAMMemberConditionPtrOutput

func (ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionPtrOutputWithContext 

func (i ConnectionIAMMemberConditionArgs) ToConnectionIAMMemberConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMMemberConditionPtrOutput

type ConnectionIAMMemberConditionInput 

type ConnectionIAMMemberConditionInput interface {
	pulumi.Input

	ToConnectionIAMMemberConditionOutput() ConnectionIAMMemberConditionOutput
	ToConnectionIAMMemberConditionOutputWithContext(context.Context) ConnectionIAMMemberConditionOutput
}

ConnectionIAMMemberConditionInput is an input type that accepts ConnectionIAMMemberConditionArgs and ConnectionIAMMemberConditionOutput values. You can construct a concrete instance of `ConnectionIAMMemberConditionInput` via: 

ConnectionIAMMemberConditionArgs{...}

type ConnectionIAMMemberConditionOutput 

type ConnectionIAMMemberConditionOutput struct{ *pulumi.OutputState }

func (ConnectionIAMMemberConditionOutput) Description 

func (o ConnectionIAMMemberConditionOutput) Description() pulumi.StringPtrOutput

func (ConnectionIAMMemberConditionOutput) ElementType 

func (ConnectionIAMMemberConditionOutput) ElementType() reflect.Type

func (ConnectionIAMMemberConditionOutput) Expression 

func (o ConnectionIAMMemberConditionOutput) Expression() pulumi.StringOutput

func (ConnectionIAMMemberConditionOutput) Title 

func (o ConnectionIAMMemberConditionOutput) Title() pulumi.StringOutput

func (ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionOutput 

func (o ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionOutput() ConnectionIAMMemberConditionOutput

func (ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionOutputWithContext 

func (o ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionOutputWithContext(ctx context.Context) ConnectionIAMMemberConditionOutput

func (ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionPtrOutput 

func (o ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionPtrOutput() ConnectionIAMMemberConditionPtrOutput

func (ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionPtrOutputWithContext 

func (o ConnectionIAMMemberConditionOutput) ToConnectionIAMMemberConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMMemberConditionPtrOutput

type ConnectionIAMMemberConditionPtrInput 

type ConnectionIAMMemberConditionPtrInput interface {
	pulumi.Input

	ToConnectionIAMMemberConditionPtrOutput() ConnectionIAMMemberConditionPtrOutput
	ToConnectionIAMMemberConditionPtrOutputWithContext(context.Context) ConnectionIAMMemberConditionPtrOutput
}

ConnectionIAMMemberConditionPtrInput is an input type that accepts ConnectionIAMMemberConditionArgs, ConnectionIAMMemberConditionPtr and ConnectionIAMMemberConditionPtrOutput values. You can construct a concrete instance of `ConnectionIAMMemberConditionPtrInput` via: 

        ConnectionIAMMemberConditionArgs{...}

or:

        nil

func ConnectionIAMMemberConditionPtr 

func ConnectionIAMMemberConditionPtr(v *ConnectionIAMMemberConditionArgs) ConnectionIAMMemberConditionPtrInput

type ConnectionIAMMemberConditionPtrOutput 

type ConnectionIAMMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (ConnectionIAMMemberConditionPtrOutput) Description 

func (o ConnectionIAMMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ConnectionIAMMemberConditionPtrOutput) Elem 

func (o ConnectionIAMMemberConditionPtrOutput) Elem() ConnectionIAMMemberConditionOutput

func (ConnectionIAMMemberConditionPtrOutput) ElementType 

func (ConnectionIAMMemberConditionPtrOutput) ElementType() reflect.Type

func (ConnectionIAMMemberConditionPtrOutput) Expression 

func (o ConnectionIAMMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ConnectionIAMMemberConditionPtrOutput) Title 

func (o ConnectionIAMMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ConnectionIAMMemberConditionPtrOutput) ToConnectionIAMMemberConditionPtrOutput 

func (o ConnectionIAMMemberConditionPtrOutput) ToConnectionIAMMemberConditionPtrOutput() ConnectionIAMMemberConditionPtrOutput

func (ConnectionIAMMemberConditionPtrOutput) ToConnectionIAMMemberConditionPtrOutputWithContext 

func (o ConnectionIAMMemberConditionPtrOutput) ToConnectionIAMMemberConditionPtrOutputWithContext(ctx context.Context) ConnectionIAMMemberConditionPtrOutput

type ConnectionIAMMemberInput 

type ConnectionIAMMemberInput interface {
	pulumi.Input

	ToConnectionIAMMemberOutput() ConnectionIAMMemberOutput
	ToConnectionIAMMemberOutputWithContext(ctx context.Context) ConnectionIAMMemberOutput
}

type ConnectionIAMMemberMap 

type ConnectionIAMMemberMap map[string]ConnectionIAMMemberInput

func (ConnectionIAMMemberMap) ElementType 

func (ConnectionIAMMemberMap) ElementType() reflect.Type

func (ConnectionIAMMemberMap) ToConnectionIAMMemberMapOutput 

func (i ConnectionIAMMemberMap) ToConnectionIAMMemberMapOutput() ConnectionIAMMemberMapOutput

func (ConnectionIAMMemberMap) ToConnectionIAMMemberMapOutputWithContext 

func (i ConnectionIAMMemberMap) ToConnectionIAMMemberMapOutputWithContext(ctx context.Context) ConnectionIAMMemberMapOutput

type ConnectionIAMMemberMapInput 

type ConnectionIAMMemberMapInput interface {
	pulumi.Input

	ToConnectionIAMMemberMapOutput() ConnectionIAMMemberMapOutput
	ToConnectionIAMMemberMapOutputWithContext(context.Context) ConnectionIAMMemberMapOutput
}

ConnectionIAMMemberMapInput is an input type that accepts ConnectionIAMMemberMap and ConnectionIAMMemberMapOutput values. You can construct a concrete instance of `ConnectionIAMMemberMapInput` via: 

ConnectionIAMMemberMap{ "key": ConnectionIAMMemberArgs{...} }

type ConnectionIAMMemberMapOutput 

type ConnectionIAMMemberMapOutput struct{ *pulumi.OutputState }

func (ConnectionIAMMemberMapOutput) ElementType 

func (ConnectionIAMMemberMapOutput) ElementType() reflect.Type

func (ConnectionIAMMemberMapOutput) MapIndex 

func (o ConnectionIAMMemberMapOutput) MapIndex(k pulumi.StringInput) ConnectionIAMMemberOutput

func (ConnectionIAMMemberMapOutput) ToConnectionIAMMemberMapOutput 

func (o ConnectionIAMMemberMapOutput) ToConnectionIAMMemberMapOutput() ConnectionIAMMemberMapOutput

func (ConnectionIAMMemberMapOutput) ToConnectionIAMMemberMapOutputWithContext 

func (o ConnectionIAMMemberMapOutput) ToConnectionIAMMemberMapOutputWithContext(ctx context.Context) ConnectionIAMMemberMapOutput

type ConnectionIAMMemberOutput 

type ConnectionIAMMemberOutput struct{ *pulumi.OutputState }

func (ConnectionIAMMemberOutput) Condition 

func (o ConnectionIAMMemberOutput) Condition() ConnectionIAMMemberConditionPtrOutput

func (ConnectionIAMMemberOutput) ElementType 

func (ConnectionIAMMemberOutput) ElementType() reflect.Type

func (ConnectionIAMMemberOutput) Etag 

func (o ConnectionIAMMemberOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ConnectionIAMMemberOutput) Location 

func (o ConnectionIAMMemberOutput) Location() pulumi.StringOutput

The location for the resource Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMMemberOutput) Member 

func (o ConnectionIAMMemberOutput) Member() pulumi.StringOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (ConnectionIAMMemberOutput) Name 

func (o ConnectionIAMMemberOutput) Name() pulumi.StringOutput

Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMMemberOutput) Project 

func (o ConnectionIAMMemberOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ConnectionIAMMemberOutput) Role 

func (o ConnectionIAMMemberOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (ConnectionIAMMemberOutput) ToConnectionIAMMemberOutput 

func (o ConnectionIAMMemberOutput) ToConnectionIAMMemberOutput() ConnectionIAMMemberOutput

func (ConnectionIAMMemberOutput) ToConnectionIAMMemberOutputWithContext 

func (o ConnectionIAMMemberOutput) ToConnectionIAMMemberOutputWithContext(ctx context.Context) ConnectionIAMMemberOutput

type ConnectionIAMMemberState 

type ConnectionIAMMemberState struct {
	Condition ConnectionIAMMemberConditionPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringPtrInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `cloudbuildv2.ConnectionIAMBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ConnectionIAMMemberState) ElementType 

func (ConnectionIAMMemberState) ElementType() reflect.Type

type ConnectionIAMPolicy 

type ConnectionIAMPolicy struct {
	pulumi.CustomResourceState

	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringOutput `pulumi:"name"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

Three different resources help you manage your IAM policy for Cloud Build v2 Connection. Each of these resources serves a different use case:

* `cloudbuildv2.ConnectionIAMPolicy`: Authoritative. Sets the IAM policy for the connection and replaces any existing policy already attached. * `cloudbuildv2.ConnectionIAMBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the connection are preserved. * `cloudbuildv2.ConnectionIAMMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the connection are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `cloudbuildv2.ConnectionIAMPolicy`: Retrieves the IAM policy for the connection

> **Note:** `cloudbuildv2.ConnectionIAMPolicy` **cannot** be used in conjunction with `cloudbuildv2.ConnectionIAMBinding` and `cloudbuildv2.ConnectionIAMMember` or they will fight over what your policy should be.

> **Note:** `cloudbuildv2.ConnectionIAMBinding` resources **can be** used in conjunction with `cloudbuildv2.ConnectionIAMMember` resources **only if** they do not grant privilege to the same role.

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/cloudbuild.connectionViewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnectionIAMPolicy(ctx, "policy", &cloudbuildv2.ConnectionIAMPolicyArgs{
			Project:    pulumi.Any(my_connection.Project),
			Location:   pulumi.Any(my_connection.Location),
			Name:       pulumi.Any(my_connection.Name),
			PolicyData: pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMBinding(ctx, "binding", &cloudbuildv2.ConnectionIAMBindingArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_cloudbuildv2\_connection\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.NewConnectionIAMMember(ctx, "member", &cloudbuildv2.ConnectionIAMMemberArgs{
			Project:  pulumi.Any(my_connection.Project),
			Location: pulumi.Any(my_connection.Location),
			Name:     pulumi.Any(my_connection.Name),
			Role:     pulumi.String("roles/cloudbuild.connectionViewer"),
			Member:   pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/connections/{{name}}

* {{project}}/{{location}}/{{name}}

* {{location}}/{{name}}

* {{name}}

Any variables not passed in the import command will be taken from the provider configuration.

Cloud Build v2 connection IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMPolicy:ConnectionIAMPolicy editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMPolicy:ConnectionIAMPolicy editor "projects/{{project}}/locations/{{location}}/connections/{{connection}} roles/cloudbuild.connectionViewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:cloudbuildv2/connectionIAMPolicy:ConnectionIAMPolicy editor projects/{{project}}/locations/{{location}}/connections/{{connection}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetConnectionIAMPolicy 

func GetConnectionIAMPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectionIAMPolicyState, opts ...pulumi.ResourceOption) (*ConnectionIAMPolicy, error)

GetConnectionIAMPolicy gets an existing ConnectionIAMPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConnectionIAMPolicy 

func NewConnectionIAMPolicy(ctx *pulumi.Context,
	name string, args *ConnectionIAMPolicyArgs, opts ...pulumi.ResourceOption) (*ConnectionIAMPolicy, error)

NewConnectionIAMPolicy registers a new resource with the given unique name, arguments, and options.

func (*ConnectionIAMPolicy) ElementType 

func (*ConnectionIAMPolicy) ElementType() reflect.Type

func (*ConnectionIAMPolicy) ToConnectionIAMPolicyOutput 

func (i *ConnectionIAMPolicy) ToConnectionIAMPolicyOutput() ConnectionIAMPolicyOutput

func (*ConnectionIAMPolicy) ToConnectionIAMPolicyOutputWithContext 

func (i *ConnectionIAMPolicy) ToConnectionIAMPolicyOutputWithContext(ctx context.Context) ConnectionIAMPolicyOutput

type ConnectionIAMPolicyArgs 

type ConnectionIAMPolicyArgs struct {
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a ConnectionIAMPolicy resource.

func (ConnectionIAMPolicyArgs) ElementType 

func (ConnectionIAMPolicyArgs) ElementType() reflect.Type

type ConnectionIAMPolicyArray 

type ConnectionIAMPolicyArray []ConnectionIAMPolicyInput

func (ConnectionIAMPolicyArray) ElementType 

func (ConnectionIAMPolicyArray) ElementType() reflect.Type

func (ConnectionIAMPolicyArray) ToConnectionIAMPolicyArrayOutput 

func (i ConnectionIAMPolicyArray) ToConnectionIAMPolicyArrayOutput() ConnectionIAMPolicyArrayOutput

func (ConnectionIAMPolicyArray) ToConnectionIAMPolicyArrayOutputWithContext 

func (i ConnectionIAMPolicyArray) ToConnectionIAMPolicyArrayOutputWithContext(ctx context.Context) ConnectionIAMPolicyArrayOutput

type ConnectionIAMPolicyArrayInput 

type ConnectionIAMPolicyArrayInput interface {
	pulumi.Input

	ToConnectionIAMPolicyArrayOutput() ConnectionIAMPolicyArrayOutput
	ToConnectionIAMPolicyArrayOutputWithContext(context.Context) ConnectionIAMPolicyArrayOutput
}

ConnectionIAMPolicyArrayInput is an input type that accepts ConnectionIAMPolicyArray and ConnectionIAMPolicyArrayOutput values. You can construct a concrete instance of `ConnectionIAMPolicyArrayInput` via: 

ConnectionIAMPolicyArray{ ConnectionIAMPolicyArgs{...} }

type ConnectionIAMPolicyArrayOutput 

type ConnectionIAMPolicyArrayOutput struct{ *pulumi.OutputState }

func (ConnectionIAMPolicyArrayOutput) ElementType 

func (ConnectionIAMPolicyArrayOutput) ElementType() reflect.Type

func (ConnectionIAMPolicyArrayOutput) Index 

func (o ConnectionIAMPolicyArrayOutput) Index(i pulumi.IntInput) ConnectionIAMPolicyOutput

func (ConnectionIAMPolicyArrayOutput) ToConnectionIAMPolicyArrayOutput 

func (o ConnectionIAMPolicyArrayOutput) ToConnectionIAMPolicyArrayOutput() ConnectionIAMPolicyArrayOutput

func (ConnectionIAMPolicyArrayOutput) ToConnectionIAMPolicyArrayOutputWithContext 

func (o ConnectionIAMPolicyArrayOutput) ToConnectionIAMPolicyArrayOutputWithContext(ctx context.Context) ConnectionIAMPolicyArrayOutput

type ConnectionIAMPolicyInput 

type ConnectionIAMPolicyInput interface {
	pulumi.Input

	ToConnectionIAMPolicyOutput() ConnectionIAMPolicyOutput
	ToConnectionIAMPolicyOutputWithContext(ctx context.Context) ConnectionIAMPolicyOutput
}

type ConnectionIAMPolicyMap 

type ConnectionIAMPolicyMap map[string]ConnectionIAMPolicyInput

func (ConnectionIAMPolicyMap) ElementType 

func (ConnectionIAMPolicyMap) ElementType() reflect.Type

func (ConnectionIAMPolicyMap) ToConnectionIAMPolicyMapOutput 

func (i ConnectionIAMPolicyMap) ToConnectionIAMPolicyMapOutput() ConnectionIAMPolicyMapOutput

func (ConnectionIAMPolicyMap) ToConnectionIAMPolicyMapOutputWithContext 

func (i ConnectionIAMPolicyMap) ToConnectionIAMPolicyMapOutputWithContext(ctx context.Context) ConnectionIAMPolicyMapOutput

type ConnectionIAMPolicyMapInput 

type ConnectionIAMPolicyMapInput interface {
	pulumi.Input

	ToConnectionIAMPolicyMapOutput() ConnectionIAMPolicyMapOutput
	ToConnectionIAMPolicyMapOutputWithContext(context.Context) ConnectionIAMPolicyMapOutput
}

ConnectionIAMPolicyMapInput is an input type that accepts ConnectionIAMPolicyMap and ConnectionIAMPolicyMapOutput values. You can construct a concrete instance of `ConnectionIAMPolicyMapInput` via: 

ConnectionIAMPolicyMap{ "key": ConnectionIAMPolicyArgs{...} }

type ConnectionIAMPolicyMapOutput 

type ConnectionIAMPolicyMapOutput struct{ *pulumi.OutputState }

func (ConnectionIAMPolicyMapOutput) ElementType 

func (ConnectionIAMPolicyMapOutput) ElementType() reflect.Type

func (ConnectionIAMPolicyMapOutput) MapIndex 

func (o ConnectionIAMPolicyMapOutput) MapIndex(k pulumi.StringInput) ConnectionIAMPolicyOutput

func (ConnectionIAMPolicyMapOutput) ToConnectionIAMPolicyMapOutput 

func (o ConnectionIAMPolicyMapOutput) ToConnectionIAMPolicyMapOutput() ConnectionIAMPolicyMapOutput

func (ConnectionIAMPolicyMapOutput) ToConnectionIAMPolicyMapOutputWithContext 

func (o ConnectionIAMPolicyMapOutput) ToConnectionIAMPolicyMapOutputWithContext(ctx context.Context) ConnectionIAMPolicyMapOutput

type ConnectionIAMPolicyOutput 

type ConnectionIAMPolicyOutput struct{ *pulumi.OutputState }

func (ConnectionIAMPolicyOutput) ElementType 

func (ConnectionIAMPolicyOutput) ElementType() reflect.Type

func (ConnectionIAMPolicyOutput) Etag 

func (o ConnectionIAMPolicyOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ConnectionIAMPolicyOutput) Location 

func (o ConnectionIAMPolicyOutput) Location() pulumi.StringOutput

The location for the resource Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMPolicyOutput) Name 

func (o ConnectionIAMPolicyOutput) Name() pulumi.StringOutput

Used to find the parent resource to bind the IAM policy to

func (ConnectionIAMPolicyOutput) PolicyData 

func (o ConnectionIAMPolicyOutput) PolicyData() pulumi.StringOutput

The policy data generated by a `organizations.getIAMPolicy` data source.

func (ConnectionIAMPolicyOutput) Project 

func (o ConnectionIAMPolicyOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ConnectionIAMPolicyOutput) ToConnectionIAMPolicyOutput 

func (o ConnectionIAMPolicyOutput) ToConnectionIAMPolicyOutput() ConnectionIAMPolicyOutput

func (ConnectionIAMPolicyOutput) ToConnectionIAMPolicyOutputWithContext 

func (o ConnectionIAMPolicyOutput) ToConnectionIAMPolicyOutputWithContext(ctx context.Context) ConnectionIAMPolicyOutput

type ConnectionIAMPolicyState 

type ConnectionIAMPolicyState struct {
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

func (ConnectionIAMPolicyState) ElementType 

func (ConnectionIAMPolicyState) ElementType() reflect.Type

type ConnectionInput 

type ConnectionInput interface {
	pulumi.Input

	ToConnectionOutput() ConnectionOutput
	ToConnectionOutputWithContext(ctx context.Context) ConnectionOutput
}

type ConnectionInstallationState 

type ConnectionInstallationState struct {
	// (Output)
	// Output only. Link to follow for next action. Empty string if the installation is already complete.
	ActionUri *string `pulumi:"actionUri"`
	// (Output)
	// Output only. Message of what the user should do next to continue the installation. Empty string if the installation is already complete.
	Message *string `pulumi:"message"`
	// (Output)
	// Output only. Current step of the installation process.
	Stage *string `pulumi:"stage"`
}

type ConnectionInstallationStateArgs 

type ConnectionInstallationStateArgs struct {
	// (Output)
	// Output only. Link to follow for next action. Empty string if the installation is already complete.
	ActionUri pulumi.StringPtrInput `pulumi:"actionUri"`
	// (Output)
	// Output only. Message of what the user should do next to continue the installation. Empty string if the installation is already complete.
	Message pulumi.StringPtrInput `pulumi:"message"`
	// (Output)
	// Output only. Current step of the installation process.
	Stage pulumi.StringPtrInput `pulumi:"stage"`
}

func (ConnectionInstallationStateArgs) ElementType 

func (ConnectionInstallationStateArgs) ElementType() reflect.Type

func (ConnectionInstallationStateArgs) ToConnectionInstallationStateOutput 

func (i ConnectionInstallationStateArgs) ToConnectionInstallationStateOutput() ConnectionInstallationStateOutput

func (ConnectionInstallationStateArgs) ToConnectionInstallationStateOutputWithContext 

func (i ConnectionInstallationStateArgs) ToConnectionInstallationStateOutputWithContext(ctx context.Context) ConnectionInstallationStateOutput

type ConnectionInstallationStateArray 

type ConnectionInstallationStateArray []ConnectionInstallationStateInput

func (ConnectionInstallationStateArray) ElementType 

func (ConnectionInstallationStateArray) ElementType() reflect.Type

func (ConnectionInstallationStateArray) ToConnectionInstallationStateArrayOutput 

func (i ConnectionInstallationStateArray) ToConnectionInstallationStateArrayOutput() ConnectionInstallationStateArrayOutput

func (ConnectionInstallationStateArray) ToConnectionInstallationStateArrayOutputWithContext 

func (i ConnectionInstallationStateArray) ToConnectionInstallationStateArrayOutputWithContext(ctx context.Context) ConnectionInstallationStateArrayOutput

type ConnectionInstallationStateArrayInput 

type ConnectionInstallationStateArrayInput interface {
	pulumi.Input

	ToConnectionInstallationStateArrayOutput() ConnectionInstallationStateArrayOutput
	ToConnectionInstallationStateArrayOutputWithContext(context.Context) ConnectionInstallationStateArrayOutput
}

ConnectionInstallationStateArrayInput is an input type that accepts ConnectionInstallationStateArray and ConnectionInstallationStateArrayOutput values. You can construct a concrete instance of `ConnectionInstallationStateArrayInput` via: 

ConnectionInstallationStateArray{ ConnectionInstallationStateArgs{...} }

type ConnectionInstallationStateArrayOutput 

type ConnectionInstallationStateArrayOutput struct{ *pulumi.OutputState }

func (ConnectionInstallationStateArrayOutput) ElementType 

func (ConnectionInstallationStateArrayOutput) ElementType() reflect.Type

func (ConnectionInstallationStateArrayOutput) Index 

func (o ConnectionInstallationStateArrayOutput) Index(i pulumi.IntInput) ConnectionInstallationStateOutput

func (ConnectionInstallationStateArrayOutput) ToConnectionInstallationStateArrayOutput 

func (o ConnectionInstallationStateArrayOutput) ToConnectionInstallationStateArrayOutput() ConnectionInstallationStateArrayOutput

func (ConnectionInstallationStateArrayOutput) ToConnectionInstallationStateArrayOutputWithContext 

func (o ConnectionInstallationStateArrayOutput) ToConnectionInstallationStateArrayOutputWithContext(ctx context.Context) ConnectionInstallationStateArrayOutput

type ConnectionInstallationStateInput 

type ConnectionInstallationStateInput interface {
	pulumi.Input

	ToConnectionInstallationStateOutput() ConnectionInstallationStateOutput
	ToConnectionInstallationStateOutputWithContext(context.Context) ConnectionInstallationStateOutput
}

ConnectionInstallationStateInput is an input type that accepts ConnectionInstallationStateArgs and ConnectionInstallationStateOutput values. You can construct a concrete instance of `ConnectionInstallationStateInput` via: 

ConnectionInstallationStateArgs{...}

type ConnectionInstallationStateOutput 

type ConnectionInstallationStateOutput struct{ *pulumi.OutputState }

func (ConnectionInstallationStateOutput) ActionUri 

func (o ConnectionInstallationStateOutput) ActionUri() pulumi.StringPtrOutput

(Output) Output only. Link to follow for next action. Empty string if the installation is already complete.

func (ConnectionInstallationStateOutput) ElementType 

func (ConnectionInstallationStateOutput) ElementType() reflect.Type

func (ConnectionInstallationStateOutput) Message 

func (o ConnectionInstallationStateOutput) Message() pulumi.StringPtrOutput

(Output) Output only. Message of what the user should do next to continue the installation. Empty string if the installation is already complete.

func (ConnectionInstallationStateOutput) Stage 

func (o ConnectionInstallationStateOutput) Stage() pulumi.StringPtrOutput

(Output) Output only. Current step of the installation process.

func (ConnectionInstallationStateOutput) ToConnectionInstallationStateOutput 

func (o ConnectionInstallationStateOutput) ToConnectionInstallationStateOutput() ConnectionInstallationStateOutput

func (ConnectionInstallationStateOutput) ToConnectionInstallationStateOutputWithContext 

func (o ConnectionInstallationStateOutput) ToConnectionInstallationStateOutputWithContext(ctx context.Context) ConnectionInstallationStateOutput

type ConnectionMap 

type ConnectionMap map[string]ConnectionInput

func (ConnectionMap) ElementType 

func (ConnectionMap) ElementType() reflect.Type

func (ConnectionMap) ToConnectionMapOutput 

func (i ConnectionMap) ToConnectionMapOutput() ConnectionMapOutput

func (ConnectionMap) ToConnectionMapOutputWithContext 

func (i ConnectionMap) ToConnectionMapOutputWithContext(ctx context.Context) ConnectionMapOutput

type ConnectionMapInput 

type ConnectionMapInput interface {
	pulumi.Input

	ToConnectionMapOutput() ConnectionMapOutput
	ToConnectionMapOutputWithContext(context.Context) ConnectionMapOutput
}

ConnectionMapInput is an input type that accepts ConnectionMap and ConnectionMapOutput values. You can construct a concrete instance of `ConnectionMapInput` via: 

ConnectionMap{ "key": ConnectionArgs{...} }

type ConnectionMapOutput 

type ConnectionMapOutput struct{ *pulumi.OutputState }

func (ConnectionMapOutput) ElementType 

func (ConnectionMapOutput) ElementType() reflect.Type

func (ConnectionMapOutput) MapIndex 

func (o ConnectionMapOutput) MapIndex(k pulumi.StringInput) ConnectionOutput

func (ConnectionMapOutput) ToConnectionMapOutput 

func (o ConnectionMapOutput) ToConnectionMapOutput() ConnectionMapOutput

func (ConnectionMapOutput) ToConnectionMapOutputWithContext 

func (o ConnectionMapOutput) ToConnectionMapOutputWithContext(ctx context.Context) ConnectionMapOutput

type ConnectionOutput 

type ConnectionOutput struct{ *pulumi.OutputState }

func (ConnectionOutput) Annotations 

func (o ConnectionOutput) Annotations() pulumi.StringMapOutput

Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.

func (ConnectionOutput) CreateTime 

func (o ConnectionOutput) CreateTime() pulumi.StringOutput

Output only. Server assigned timestamp for when the connection was created.

func (ConnectionOutput) Disabled 

func (o ConnectionOutput) Disabled() pulumi.BoolPtrOutput

If disabled is set to true, functionality is disabled for this connection. Repository based API methods and webhooks processing for repositories in this connection will be disabled.

func (ConnectionOutput) EffectiveAnnotations 

func (o ConnectionOutput) EffectiveAnnotations() pulumi.StringMapOutput

All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through Terraform, other clients and services.

func (ConnectionOutput) ElementType 

func (ConnectionOutput) ElementType() reflect.Type

func (ConnectionOutput) Etag 

func (o ConnectionOutput) Etag() pulumi.StringOutput

This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.

func (ConnectionOutput) GithubConfig 

func (o ConnectionOutput) GithubConfig() ConnectionGithubConfigPtrOutput

Configuration for connections to github.com. Structure is documented below.

func (ConnectionOutput) GithubEnterpriseConfig 

func (o ConnectionOutput) GithubEnterpriseConfig() ConnectionGithubEnterpriseConfigPtrOutput

Configuration for connections to an instance of GitHub Enterprise. Structure is documented below.

func (ConnectionOutput) GitlabConfig 

func (o ConnectionOutput) GitlabConfig() ConnectionGitlabConfigPtrOutput

Configuration for connections to gitlab.com or an instance of GitLab Enterprise. Structure is documented below.

func (ConnectionOutput) InstallationStates 

func (o ConnectionOutput) InstallationStates() ConnectionInstallationStateArrayOutput

Output only. Installation state of the Connection. Structure is documented below.

func (ConnectionOutput) Location 

func (o ConnectionOutput) Location() pulumi.StringOutput

The location for the resource

***

func (ConnectionOutput) Name 

func (o ConnectionOutput) Name() pulumi.StringOutput

Immutable. The resource name of the connection.

func (ConnectionOutput) Project 

func (o ConnectionOutput) Project() pulumi.StringOutput

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

func (ConnectionOutput) Reconciling 

func (o ConnectionOutput) Reconciling() pulumi.BoolOutput

Output only. Set to true when the connection is being set up or updated in the background.

func (ConnectionOutput) ToConnectionOutput 

func (o ConnectionOutput) ToConnectionOutput() ConnectionOutput

func (ConnectionOutput) ToConnectionOutputWithContext 

func (o ConnectionOutput) ToConnectionOutputWithContext(ctx context.Context) ConnectionOutput

func (ConnectionOutput) UpdateTime 

func (o ConnectionOutput) UpdateTime() pulumi.StringOutput

Output only. Server assigned timestamp for when the connection was updated.

type ConnectionState 

type ConnectionState struct {
	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapInput
	// Output only. Server assigned timestamp for when the connection was created.
	CreateTime pulumi.StringPtrInput
	// If disabled is set to true, functionality is disabled for this connection. Repository based API methods and webhooks processing for repositories in this connection will be disabled.
	Disabled pulumi.BoolPtrInput
	// All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through
	// Terraform, other clients and services.
	EffectiveAnnotations pulumi.StringMapInput
	// This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
	Etag pulumi.StringPtrInput
	// Configuration for connections to github.com.
	// Structure is documented below.
	GithubConfig ConnectionGithubConfigPtrInput
	// Configuration for connections to an instance of GitHub Enterprise.
	// Structure is documented below.
	GithubEnterpriseConfig ConnectionGithubEnterpriseConfigPtrInput
	// Configuration for connections to gitlab.com or an instance of GitLab Enterprise.
	// Structure is documented below.
	GitlabConfig ConnectionGitlabConfigPtrInput
	// Output only. Installation state of the Connection.
	// Structure is documented below.
	InstallationStates ConnectionInstallationStateArrayInput
	// The location for the resource
	//
	// ***
	Location pulumi.StringPtrInput
	// Immutable. The resource name of the connection.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Output only. Set to true when the connection is being set up or updated in the background.
	Reconciling pulumi.BoolPtrInput
	// Output only. Server assigned timestamp for when the connection was updated.
	UpdateTime pulumi.StringPtrInput
}

func (ConnectionState) ElementType 

func (ConnectionState) ElementType() reflect.Type

type GetConnectionIamPolicyArgs 

type GetConnectionIamPolicyArgs struct {
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location *string `pulumi:"location"`
	// Used to find the parent resource to bind the IAM policy to
	Name string `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project *string `pulumi:"project"`
}

A collection of arguments for invoking getConnectionIamPolicy.

type GetConnectionIamPolicyOutputArgs 

type GetConnectionIamPolicyOutputArgs struct {
	// The location for the resource Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput `pulumi:"location"`
	// Used to find the parent resource to bind the IAM policy to
	Name pulumi.StringInput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput `pulumi:"project"`
}

A collection of arguments for invoking getConnectionIamPolicy.

func (GetConnectionIamPolicyOutputArgs) ElementType 

func (GetConnectionIamPolicyOutputArgs) ElementType() reflect.Type

type GetConnectionIamPolicyResult 

type GetConnectionIamPolicyResult struct {
	// (Computed) The etag of the IAM policy.
	Etag string `pulumi:"etag"`
	// The provider-assigned unique ID for this managed resource.
	Id       string `pulumi:"id"`
	Location string `pulumi:"location"`
	Name     string `pulumi:"name"`
	// (Required only by `cloudbuildv2.ConnectionIAMPolicy`) The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData string `pulumi:"policyData"`
	Project    string `pulumi:"project"`
}

A collection of values returned by getConnectionIamPolicy.

func GetConnectionIamPolicy 

func GetConnectionIamPolicy(ctx *pulumi.Context, args *GetConnectionIamPolicyArgs, opts ...pulumi.InvokeOption) (*GetConnectionIamPolicyResult, error)

Retrieves the current IAM policy data for connection

## example

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuildv2.GetConnectionIamPolicy(ctx, &cloudbuildv2.GetConnectionIamPolicyArgs{
			Project:  pulumi.StringRef(my_connection.Project),
			Location: pulumi.StringRef(my_connection.Location),
			Name:     my_connection.Name,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetConnectionIamPolicyResultOutput 

type GetConnectionIamPolicyResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getConnectionIamPolicy.

func GetConnectionIamPolicyOutput 

func GetConnectionIamPolicyOutput(ctx *pulumi.Context, args GetConnectionIamPolicyOutputArgs, opts ...pulumi.InvokeOption) GetConnectionIamPolicyResultOutput

func (GetConnectionIamPolicyResultOutput) ElementType 

func (GetConnectionIamPolicyResultOutput) ElementType() reflect.Type

func (GetConnectionIamPolicyResultOutput) Etag 

func (o GetConnectionIamPolicyResultOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (GetConnectionIamPolicyResultOutput) Id 

func (o GetConnectionIamPolicyResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetConnectionIamPolicyResultOutput) Location 

func (o GetConnectionIamPolicyResultOutput) Location() pulumi.StringOutput

func (GetConnectionIamPolicyResultOutput) Name 

func (o GetConnectionIamPolicyResultOutput) Name() pulumi.StringOutput

func (GetConnectionIamPolicyResultOutput) PolicyData 

func (o GetConnectionIamPolicyResultOutput) PolicyData() pulumi.StringOutput

(Required only by `cloudbuildv2.ConnectionIAMPolicy`) The policy data generated by a `organizations.getIAMPolicy` data source.

func (GetConnectionIamPolicyResultOutput) Project 

func (o GetConnectionIamPolicyResultOutput) Project() pulumi.StringOutput

func (GetConnectionIamPolicyResultOutput) ToGetConnectionIamPolicyResultOutput 

func (o GetConnectionIamPolicyResultOutput) ToGetConnectionIamPolicyResultOutput() GetConnectionIamPolicyResultOutput

func (GetConnectionIamPolicyResultOutput) ToGetConnectionIamPolicyResultOutputWithContext 

func (o GetConnectionIamPolicyResultOutput) ToGetConnectionIamPolicyResultOutputWithContext(ctx context.Context) GetConnectionIamPolicyResultOutput

type Repository 

type Repository struct {
	pulumi.CustomResourceState

	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapOutput `pulumi:"annotations"`
	// Output only. Server assigned timestamp for when the connection was created.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through
	// Terraform, other clients and services.
	EffectiveAnnotations pulumi.StringMapOutput `pulumi:"effectiveAnnotations"`
	// This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The location for the resource
	Location pulumi.StringOutput `pulumi:"location"`
	// Name of the repository.
	Name pulumi.StringOutput `pulumi:"name"`
	// The connection for the resource
	//
	// ***
	ParentConnection pulumi.StringOutput `pulumi:"parentConnection"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// Required. Git Clone HTTPS URI.
	RemoteUri pulumi.StringOutput `pulumi:"remoteUri"`
	// Output only. Server assigned timestamp for when the connection was updated.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

A repository associated to a parent connection.

To get more information about Repository, see:

* [API documentation](https://cloud.google.com/build/docs/api/reference/rest) * How-to Guides

## Example Usage

### Cloudbuildv2 Repository Ghe Doc

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/secretmanager"
"github.com/pulumi/pulumi-std/sdk/go/std"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "private-key-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("ghe-pk-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "private-key.pem",
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "private-key-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     private_key_secret.ID(),
			SecretData: invokeFile.Result,
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecret(ctx, "webhook-secret-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("github-token-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "webhook-secret-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     webhook_secret_secret.ID(),
			SecretData: pulumi.String("<webhook-secret-data>"),
		})
		if err != nil {
			return err
		}
		p4sa_secretAccessor, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/secretmanager.secretAccessor",
					Members: []string{
						"serviceAccount:service-123456789@gcp-sa-cloudbuild.iam.gserviceaccount.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy-pk", &secretmanager.SecretIamPolicyArgs{
			SecretId:   private_key_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy-whs", &secretmanager.SecretIamPolicyArgs{
			SecretId:   webhook_secret_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnection(ctx, "my-connection", &cloudbuildv2.ConnectionArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("my-terraform-ghe-connection"),
			GithubEnterpriseConfig: &cloudbuildv2.ConnectionGithubEnterpriseConfigArgs{
				HostUri:                    pulumi.String("https://ghe.com"),
				PrivateKeySecretVersion:    private_key_secret_version.ID(),
				WebhookSecretSecretVersion: webhook_secret_secret_version.ID(),
				AppId:                      pulumi.Int(200),
				AppSlug:                    pulumi.String("gcb-app"),
				AppInstallationId:          pulumi.Int(300),
			},
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewRepository(ctx, "my-repository", &cloudbuildv2.RepositoryArgs{
			Name:             pulumi.String("my-terraform-ghe-repo"),
			Location:         pulumi.String("us-central1"),
			ParentConnection: my_connection.ID(),
			RemoteUri:        pulumi.String("https://ghe.com/hashicorp/terraform-provider-google.git"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Cloudbuildv2 Repository Github Doc

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudbuildv2"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/secretmanager"
"github.com/pulumi/pulumi-std/sdk/go/std"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "github-token-secret", &secretmanager.SecretArgs{
			SecretId: pulumi.String("github-token-secret"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: nil,
			},
		})
		if err != nil {
			return err
		}
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "my-github-token.txt",
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "github-token-secret-version", &secretmanager.SecretVersionArgs{
			Secret:     github_token_secret.ID(),
			SecretData: invokeFile.Result,
		})
		if err != nil {
			return err
		}
		p4sa_secretAccessor, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/secretmanager.secretAccessor",
					Members: []string{
						"serviceAccount:service-123456789@gcp-sa-cloudbuild.iam.gserviceaccount.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy", &secretmanager.SecretIamPolicyArgs{
			SecretId:   github_token_secret.SecretId,
			PolicyData: pulumi.String(p4sa_secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewConnection(ctx, "my-connection", &cloudbuildv2.ConnectionArgs{
			Location: pulumi.String("us-central1"),
			Name:     pulumi.String("my-connection"),
			GithubConfig: &cloudbuildv2.ConnectionGithubConfigArgs{
				AppInstallationId: pulumi.Int(123123),
				AuthorizerCredential: &cloudbuildv2.ConnectionGithubConfigAuthorizerCredentialArgs{
					OauthTokenSecretVersion: github_token_secret_version.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = cloudbuildv2.NewRepository(ctx, "my-repository", &cloudbuildv2.RepositoryArgs{
			Location:         pulumi.String("us-central1"),
			Name:             pulumi.String("my-repo"),
			ParentConnection: my_connection.Name,
			RemoteUri:        pulumi.String("https://github.com/myuser/myrepo.git"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Repository can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/connections/{{parent_connection}}/repositories/{{name}}`

* `{{project}}/{{location}}/{{parent_connection}}/{{name}}`

* `{{location}}/{{parent_connection}}/{{name}}`

When using the `pulumi import` command, Repository can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:cloudbuildv2/repository:Repository default projects/{{project}}/locations/{{location}}/connections/{{parent_connection}}/repositories/{{name}} ```

```sh $ pulumi import gcp:cloudbuildv2/repository:Repository default {{project}}/{{location}}/{{parent_connection}}/{{name}} ```

```sh $ pulumi import gcp:cloudbuildv2/repository:Repository default {{location}}/{{parent_connection}}/{{name}} ```

func GetRepository 

func GetRepository(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryState, opts ...pulumi.ResourceOption) (*Repository, error)

GetRepository gets an existing Repository resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRepository 

func NewRepository(ctx *pulumi.Context,
	name string, args *RepositoryArgs, opts ...pulumi.ResourceOption) (*Repository, error)

NewRepository registers a new resource with the given unique name, arguments, and options.

func (*Repository) ElementType 

func (*Repository) ElementType() reflect.Type

func (*Repository) ToRepositoryOutput 

func (i *Repository) ToRepositoryOutput() RepositoryOutput

func (*Repository) ToRepositoryOutputWithContext 

func (i *Repository) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

type RepositoryArgs 

type RepositoryArgs struct {
	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapInput
	// The location for the resource
	Location pulumi.StringPtrInput
	// Name of the repository.
	Name pulumi.StringPtrInput
	// The connection for the resource
	//
	// ***
	ParentConnection pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Required. Git Clone HTTPS URI.
	RemoteUri pulumi.StringInput
}

The set of arguments for constructing a Repository resource.

func (RepositoryArgs) ElementType 

func (RepositoryArgs) ElementType() reflect.Type

type RepositoryArray 

type RepositoryArray []RepositoryInput

func (RepositoryArray) ElementType 

func (RepositoryArray) ElementType() reflect.Type

func (RepositoryArray) ToRepositoryArrayOutput 

func (i RepositoryArray) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArray) ToRepositoryArrayOutputWithContext 

func (i RepositoryArray) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryArrayInput 

type RepositoryArrayInput interface {
	pulumi.Input

	ToRepositoryArrayOutput() RepositoryArrayOutput
	ToRepositoryArrayOutputWithContext(context.Context) RepositoryArrayOutput
}

RepositoryArrayInput is an input type that accepts RepositoryArray and RepositoryArrayOutput values. You can construct a concrete instance of `RepositoryArrayInput` via: 

RepositoryArray{ RepositoryArgs{...} }

type RepositoryArrayOutput 

type RepositoryArrayOutput struct{ *pulumi.OutputState }

func (RepositoryArrayOutput) ElementType 

func (RepositoryArrayOutput) ElementType() reflect.Type

func (RepositoryArrayOutput) Index 

func (o RepositoryArrayOutput) Index(i pulumi.IntInput) RepositoryOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutput 

func (o RepositoryArrayOutput) ToRepositoryArrayOutput() RepositoryArrayOutput

func (RepositoryArrayOutput) ToRepositoryArrayOutputWithContext 

func (o RepositoryArrayOutput) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput

type RepositoryInput 

type RepositoryInput interface {
	pulumi.Input

	ToRepositoryOutput() RepositoryOutput
	ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput
}

type RepositoryMap 

type RepositoryMap map[string]RepositoryInput

func (RepositoryMap) ElementType 

func (RepositoryMap) ElementType() reflect.Type

func (RepositoryMap) ToRepositoryMapOutput 

func (i RepositoryMap) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMap) ToRepositoryMapOutputWithContext 

func (i RepositoryMap) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryMapInput 

type RepositoryMapInput interface {
	pulumi.Input

	ToRepositoryMapOutput() RepositoryMapOutput
	ToRepositoryMapOutputWithContext(context.Context) RepositoryMapOutput
}

RepositoryMapInput is an input type that accepts RepositoryMap and RepositoryMapOutput values. You can construct a concrete instance of `RepositoryMapInput` via: 

RepositoryMap{ "key": RepositoryArgs{...} }

type RepositoryMapOutput 

type RepositoryMapOutput struct{ *pulumi.OutputState }

func (RepositoryMapOutput) ElementType 

func (RepositoryMapOutput) ElementType() reflect.Type

func (RepositoryMapOutput) MapIndex 

func (o RepositoryMapOutput) MapIndex(k pulumi.StringInput) RepositoryOutput

func (RepositoryMapOutput) ToRepositoryMapOutput 

func (o RepositoryMapOutput) ToRepositoryMapOutput() RepositoryMapOutput

func (RepositoryMapOutput) ToRepositoryMapOutputWithContext 

func (o RepositoryMapOutput) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput

type RepositoryOutput 

type RepositoryOutput struct{ *pulumi.OutputState }

func (RepositoryOutput) Annotations 

func (o RepositoryOutput) Annotations() pulumi.StringMapOutput

Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.

func (RepositoryOutput) CreateTime 

func (o RepositoryOutput) CreateTime() pulumi.StringOutput

Output only. Server assigned timestamp for when the connection was created.

func (RepositoryOutput) EffectiveAnnotations 

func (o RepositoryOutput) EffectiveAnnotations() pulumi.StringMapOutput

All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through Terraform, other clients and services.

func (RepositoryOutput) ElementType 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) Etag 

func (o RepositoryOutput) Etag() pulumi.StringOutput

This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.

func (RepositoryOutput) Location 

func (o RepositoryOutput) Location() pulumi.StringOutput

The location for the resource

func (RepositoryOutput) Name 

func (o RepositoryOutput) Name() pulumi.StringOutput

Name of the repository.

func (RepositoryOutput) ParentConnection 

func (o RepositoryOutput) ParentConnection() pulumi.StringOutput

The connection for the resource

***

func (RepositoryOutput) Project 

func (o RepositoryOutput) Project() pulumi.StringOutput

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

func (RepositoryOutput) RemoteUri 

func (o RepositoryOutput) RemoteUri() pulumi.StringOutput

Required. Git Clone HTTPS URI.

func (RepositoryOutput) ToRepositoryOutput 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext 

func (o RepositoryOutput) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

func (RepositoryOutput) UpdateTime 

func (o RepositoryOutput) UpdateTime() pulumi.StringOutput

Output only. Server assigned timestamp for when the connection was updated.

type RepositoryState 

type RepositoryState struct {
	// Allows clients 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 `effectiveAnnotations` for all of the annotations present on the resource.
	Annotations pulumi.StringMapInput
	// Output only. Server assigned timestamp for when the connection was created.
	CreateTime pulumi.StringPtrInput
	// All of annotations (key/value pairs) present on the resource in GCP, including the annotations configured through
	// Terraform, other clients and services.
	EffectiveAnnotations pulumi.StringMapInput
	// This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
	Etag pulumi.StringPtrInput
	// The location for the resource
	Location pulumi.StringPtrInput
	// Name of the repository.
	Name pulumi.StringPtrInput
	// The connection for the resource
	//
	// ***
	ParentConnection pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Required. Git Clone HTTPS URI.
	RemoteUri pulumi.StringPtrInput
	// Output only. Server assigned timestamp for when the connection was updated.
	UpdateTime pulumi.StringPtrInput
}

func (RepositoryState) ElementType 

func (RepositoryState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.