pulumiTypes.go

// Code generated by the Pulumi SDK Generator DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package v2beta

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-google-native/sdk/go/google/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

var _ = internal.GetEnvOrDefault

// Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
type AuditConfig struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs []AuditLogConfig `pulumi:"auditLogConfigs"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service *string `pulumi:"service"`
}

// AuditConfigInput is an input type that accepts AuditConfigArgs and AuditConfigOutput values.
// You can construct a concrete instance of `AuditConfigInput` via:
//
//	AuditConfigArgs{...}
type AuditConfigInput interface {
	pulumi.Input

	ToAuditConfigOutput() AuditConfigOutput
	ToAuditConfigOutputWithContext(context.Context) AuditConfigOutput
}

// Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
type AuditConfigArgs struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs AuditLogConfigArrayInput `pulumi:"auditLogConfigs"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service pulumi.StringPtrInput `pulumi:"service"`
}

func (AuditConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditConfig)(nil)).Elem()
}

func (i AuditConfigArgs) ToAuditConfigOutput() AuditConfigOutput {
	return i.ToAuditConfigOutputWithContext(context.Background())
}

func (i AuditConfigArgs) ToAuditConfigOutputWithContext(ctx context.Context) AuditConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AuditConfigOutput)
}

// AuditConfigArrayInput is an input type that accepts AuditConfigArray and AuditConfigArrayOutput values.
// You can construct a concrete instance of `AuditConfigArrayInput` via:
//
//	AuditConfigArray{ AuditConfigArgs{...} }
type AuditConfigArrayInput interface {
	pulumi.Input

	ToAuditConfigArrayOutput() AuditConfigArrayOutput
	ToAuditConfigArrayOutputWithContext(context.Context) AuditConfigArrayOutput
}

type AuditConfigArray []AuditConfigInput

func (AuditConfigArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditConfig)(nil)).Elem()
}

func (i AuditConfigArray) ToAuditConfigArrayOutput() AuditConfigArrayOutput {
	return i.ToAuditConfigArrayOutputWithContext(context.Background())
}

func (i AuditConfigArray) ToAuditConfigArrayOutputWithContext(ctx context.Context) AuditConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AuditConfigArrayOutput)
}

// Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
type AuditConfigOutput struct{ *pulumi.OutputState }

func (AuditConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditConfig)(nil)).Elem()
}

func (o AuditConfigOutput) ToAuditConfigOutput() AuditConfigOutput {
	return o
}

func (o AuditConfigOutput) ToAuditConfigOutputWithContext(ctx context.Context) AuditConfigOutput {
	return o
}

// The configuration for logging of each type of permission.
func (o AuditConfigOutput) AuditLogConfigs() AuditLogConfigArrayOutput {
	return o.ApplyT(func(v AuditConfig) []AuditLogConfig { return v.AuditLogConfigs }).(AuditLogConfigArrayOutput)
}

// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
func (o AuditConfigOutput) Service() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AuditConfig) *string { return v.Service }).(pulumi.StringPtrOutput)
}

type AuditConfigArrayOutput struct{ *pulumi.OutputState }

func (AuditConfigArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditConfig)(nil)).Elem()
}

func (o AuditConfigArrayOutput) ToAuditConfigArrayOutput() AuditConfigArrayOutput {
	return o
}

func (o AuditConfigArrayOutput) ToAuditConfigArrayOutputWithContext(ctx context.Context) AuditConfigArrayOutput {
	return o
}

func (o AuditConfigArrayOutput) Index(i pulumi.IntInput) AuditConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditConfig {
		return vs[0].([]AuditConfig)[vs[1].(int)]
	}).(AuditConfigOutput)
}

// Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
type AuditConfigResponse struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs []AuditLogConfigResponse `pulumi:"auditLogConfigs"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service string `pulumi:"service"`
}

// Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
type AuditConfigResponseOutput struct{ *pulumi.OutputState }

func (AuditConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditConfigResponse)(nil)).Elem()
}

func (o AuditConfigResponseOutput) ToAuditConfigResponseOutput() AuditConfigResponseOutput {
	return o
}

func (o AuditConfigResponseOutput) ToAuditConfigResponseOutputWithContext(ctx context.Context) AuditConfigResponseOutput {
	return o
}

// The configuration for logging of each type of permission.
func (o AuditConfigResponseOutput) AuditLogConfigs() AuditLogConfigResponseArrayOutput {
	return o.ApplyT(func(v AuditConfigResponse) []AuditLogConfigResponse { return v.AuditLogConfigs }).(AuditLogConfigResponseArrayOutput)
}

// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
func (o AuditConfigResponseOutput) Service() pulumi.StringOutput {
	return o.ApplyT(func(v AuditConfigResponse) string { return v.Service }).(pulumi.StringOutput)
}

type AuditConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (AuditConfigResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditConfigResponse)(nil)).Elem()
}

func (o AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutput() AuditConfigResponseArrayOutput {
	return o
}

func (o AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutputWithContext(ctx context.Context) AuditConfigResponseArrayOutput {
	return o
}

func (o AuditConfigResponseArrayOutput) Index(i pulumi.IntInput) AuditConfigResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditConfigResponse {
		return vs[0].([]AuditConfigResponse)[vs[1].(int)]
	}).(AuditConfigResponseOutput)
}

// Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
type AuditLogConfig struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers []string `pulumi:"exemptedMembers"`
	// The log type that this config enables.
	LogType *AuditLogConfigLogType `pulumi:"logType"`
}

// AuditLogConfigInput is an input type that accepts AuditLogConfigArgs and AuditLogConfigOutput values.
// You can construct a concrete instance of `AuditLogConfigInput` via:
//
//	AuditLogConfigArgs{...}
type AuditLogConfigInput interface {
	pulumi.Input

	ToAuditLogConfigOutput() AuditLogConfigOutput
	ToAuditLogConfigOutputWithContext(context.Context) AuditLogConfigOutput
}

// Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
type AuditLogConfigArgs struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers pulumi.StringArrayInput `pulumi:"exemptedMembers"`
	// The log type that this config enables.
	LogType AuditLogConfigLogTypePtrInput `pulumi:"logType"`
}

func (AuditLogConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditLogConfig)(nil)).Elem()
}

func (i AuditLogConfigArgs) ToAuditLogConfigOutput() AuditLogConfigOutput {
	return i.ToAuditLogConfigOutputWithContext(context.Background())
}

func (i AuditLogConfigArgs) ToAuditLogConfigOutputWithContext(ctx context.Context) AuditLogConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AuditLogConfigOutput)
}

// AuditLogConfigArrayInput is an input type that accepts AuditLogConfigArray and AuditLogConfigArrayOutput values.
// You can construct a concrete instance of `AuditLogConfigArrayInput` via:
//
//	AuditLogConfigArray{ AuditLogConfigArgs{...} }
type AuditLogConfigArrayInput interface {
	pulumi.Input

	ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput
	ToAuditLogConfigArrayOutputWithContext(context.Context) AuditLogConfigArrayOutput
}

type AuditLogConfigArray []AuditLogConfigInput

func (AuditLogConfigArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditLogConfig)(nil)).Elem()
}

func (i AuditLogConfigArray) ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput {
	return i.ToAuditLogConfigArrayOutputWithContext(context.Background())
}

func (i AuditLogConfigArray) ToAuditLogConfigArrayOutputWithContext(ctx context.Context) AuditLogConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AuditLogConfigArrayOutput)
}

// Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
type AuditLogConfigOutput struct{ *pulumi.OutputState }

func (AuditLogConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditLogConfig)(nil)).Elem()
}

func (o AuditLogConfigOutput) ToAuditLogConfigOutput() AuditLogConfigOutput {
	return o
}

func (o AuditLogConfigOutput) ToAuditLogConfigOutputWithContext(ctx context.Context) AuditLogConfigOutput {
	return o
}

// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
func (o AuditLogConfigOutput) ExemptedMembers() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AuditLogConfig) []string { return v.ExemptedMembers }).(pulumi.StringArrayOutput)
}

// The log type that this config enables.
func (o AuditLogConfigOutput) LogType() AuditLogConfigLogTypePtrOutput {
	return o.ApplyT(func(v AuditLogConfig) *AuditLogConfigLogType { return v.LogType }).(AuditLogConfigLogTypePtrOutput)
}

type AuditLogConfigArrayOutput struct{ *pulumi.OutputState }

func (AuditLogConfigArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditLogConfig)(nil)).Elem()
}

func (o AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput {
	return o
}

func (o AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutputWithContext(ctx context.Context) AuditLogConfigArrayOutput {
	return o
}

func (o AuditLogConfigArrayOutput) Index(i pulumi.IntInput) AuditLogConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditLogConfig {
		return vs[0].([]AuditLogConfig)[vs[1].(int)]
	}).(AuditLogConfigOutput)
}

// Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
type AuditLogConfigResponse struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers []string `pulumi:"exemptedMembers"`
	// The log type that this config enables.
	LogType string `pulumi:"logType"`
}

// Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
type AuditLogConfigResponseOutput struct{ *pulumi.OutputState }

func (AuditLogConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AuditLogConfigResponse)(nil)).Elem()
}

func (o AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutput() AuditLogConfigResponseOutput {
	return o
}

func (o AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutputWithContext(ctx context.Context) AuditLogConfigResponseOutput {
	return o
}

// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
func (o AuditLogConfigResponseOutput) ExemptedMembers() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AuditLogConfigResponse) []string { return v.ExemptedMembers }).(pulumi.StringArrayOutput)
}

// The log type that this config enables.
func (o AuditLogConfigResponseOutput) LogType() pulumi.StringOutput {
	return o.ApplyT(func(v AuditLogConfigResponse) string { return v.LogType }).(pulumi.StringOutput)
}

type AuditLogConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (AuditLogConfigResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]AuditLogConfigResponse)(nil)).Elem()
}

func (o AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutput() AuditLogConfigResponseArrayOutput {
	return o
}

func (o AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutputWithContext(ctx context.Context) AuditLogConfigResponseArrayOutput {
	return o
}

func (o AuditLogConfigResponseArrayOutput) Index(i pulumi.IntInput) AuditLogConfigResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AuditLogConfigResponse {
		return vs[0].([]AuditLogConfigResponse)[vs[1].(int)]
	}).(AuditLogConfigResponseOutput)
}

// Associates `members`, or principals, with a `role`.
type Binding struct {
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition *Expr `pulumi:"condition"`
	// Specifies the principals requesting access for a Google Cloud resource. `members` can have 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. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding.
	Members []string `pulumi:"members"`
	// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role *string `pulumi:"role"`
}

// BindingInput is an input type that accepts BindingArgs and BindingOutput values.
// You can construct a concrete instance of `BindingInput` via:
//
//	BindingArgs{...}
type BindingInput interface {
	pulumi.Input

	ToBindingOutput() BindingOutput
	ToBindingOutputWithContext(context.Context) BindingOutput
}

// Associates `members`, or principals, with a `role`.
type BindingArgs struct {
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition ExprPtrInput `pulumi:"condition"`
	// Specifies the principals requesting access for a Google Cloud resource. `members` can have 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. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding.
	Members pulumi.StringArrayInput `pulumi:"members"`
	// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role pulumi.StringPtrInput `pulumi:"role"`
}

func (BindingArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Binding)(nil)).Elem()
}

func (i BindingArgs) ToBindingOutput() BindingOutput {
	return i.ToBindingOutputWithContext(context.Background())
}

func (i BindingArgs) ToBindingOutputWithContext(ctx context.Context) BindingOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingOutput)
}

// BindingArrayInput is an input type that accepts BindingArray and BindingArrayOutput values.
// You can construct a concrete instance of `BindingArrayInput` via:
//
//	BindingArray{ BindingArgs{...} }
type BindingArrayInput interface {
	pulumi.Input

	ToBindingArrayOutput() BindingArrayOutput
	ToBindingArrayOutputWithContext(context.Context) BindingArrayOutput
}

type BindingArray []BindingInput

func (BindingArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]Binding)(nil)).Elem()
}

func (i BindingArray) ToBindingArrayOutput() BindingArrayOutput {
	return i.ToBindingArrayOutputWithContext(context.Background())
}

func (i BindingArray) ToBindingArrayOutputWithContext(ctx context.Context) BindingArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BindingArrayOutput)
}

// Associates `members`, or principals, with a `role`.
type BindingOutput struct{ *pulumi.OutputState }

func (BindingOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Binding)(nil)).Elem()
}

func (o BindingOutput) ToBindingOutput() BindingOutput {
	return o
}

func (o BindingOutput) ToBindingOutputWithContext(ctx context.Context) BindingOutput {
	return o
}

// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
func (o BindingOutput) Condition() ExprPtrOutput {
	return o.ApplyT(func(v Binding) *Expr { return v.Condition }).(ExprPtrOutput)
}

// Specifies the principals requesting access for a Google Cloud resource. `members` can have 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. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding.
func (o BindingOutput) Members() pulumi.StringArrayOutput {
	return o.ApplyT(func(v Binding) []string { return v.Members }).(pulumi.StringArrayOutput)
}

// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
func (o BindingOutput) Role() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Binding) *string { return v.Role }).(pulumi.StringPtrOutput)
}

type BindingArrayOutput struct{ *pulumi.OutputState }

func (BindingArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]Binding)(nil)).Elem()
}

func (o BindingArrayOutput) ToBindingArrayOutput() BindingArrayOutput {
	return o
}

func (o BindingArrayOutput) ToBindingArrayOutputWithContext(ctx context.Context) BindingArrayOutput {
	return o
}

func (o BindingArrayOutput) Index(i pulumi.IntInput) BindingOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Binding {
		return vs[0].([]Binding)[vs[1].(int)]
	}).(BindingOutput)
}

// Associates `members`, or principals, with a `role`.
type BindingResponse struct {
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition ExprResponse `pulumi:"condition"`
	// Specifies the principals requesting access for a Google Cloud resource. `members` can have 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. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding.
	Members []string `pulumi:"members"`
	// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role string `pulumi:"role"`
}

// Associates `members`, or principals, with a `role`.
type BindingResponseOutput struct{ *pulumi.OutputState }

func (BindingResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BindingResponse)(nil)).Elem()
}

func (o BindingResponseOutput) ToBindingResponseOutput() BindingResponseOutput {
	return o
}

func (o BindingResponseOutput) ToBindingResponseOutputWithContext(ctx context.Context) BindingResponseOutput {
	return o
}

// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
func (o BindingResponseOutput) Condition() ExprResponseOutput {
	return o.ApplyT(func(v BindingResponse) ExprResponse { return v.Condition }).(ExprResponseOutput)
}

// Specifies the principals requesting access for a Google Cloud resource. `members` can have 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. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding.
func (o BindingResponseOutput) Members() pulumi.StringArrayOutput {
	return o.ApplyT(func(v BindingResponse) []string { return v.Members }).(pulumi.StringArrayOutput)
}

// Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
func (o BindingResponseOutput) Role() pulumi.StringOutput {
	return o.ApplyT(func(v BindingResponse) string { return v.Role }).(pulumi.StringOutput)
}

type BindingResponseArrayOutput struct{ *pulumi.OutputState }

func (BindingResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]BindingResponse)(nil)).Elem()
}

func (o BindingResponseArrayOutput) ToBindingResponseArrayOutput() BindingResponseArrayOutput {
	return o
}

func (o BindingResponseArrayOutput) ToBindingResponseArrayOutputWithContext(ctx context.Context) BindingResponseArrayOutput {
	return o
}

func (o BindingResponseArrayOutput) Index(i pulumi.IntInput) BindingResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) BindingResponse {
		return vs[0].([]BindingResponse)[vs[1].(int)]
	}).(BindingResponseOutput)
}

// Describes the Build step of the function that builds a container from the given source.
type BuildConfig struct {
	// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
	DockerRegistry *BuildConfigDockerRegistry `pulumi:"dockerRegistry"`
	// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
	DockerRepository *string `pulumi:"dockerRepository"`
	// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
	EntryPoint *string `pulumi:"entryPoint"`
	// User-provided build-time environment variables for the function
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
	Runtime *string `pulumi:"runtime"`
	// The location of the function source code.
	Source *Source `pulumi:"source"`
	// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
	SourceToken *string `pulumi:"sourceToken"`
	// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
	WorkerPool *string `pulumi:"workerPool"`
}

// BuildConfigInput is an input type that accepts BuildConfigArgs and BuildConfigOutput values.
// You can construct a concrete instance of `BuildConfigInput` via:
//
//	BuildConfigArgs{...}
type BuildConfigInput interface {
	pulumi.Input

	ToBuildConfigOutput() BuildConfigOutput
	ToBuildConfigOutputWithContext(context.Context) BuildConfigOutput
}

// Describes the Build step of the function that builds a container from the given source.
type BuildConfigArgs struct {
	// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
	DockerRegistry BuildConfigDockerRegistryPtrInput `pulumi:"dockerRegistry"`
	// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
	DockerRepository pulumi.StringPtrInput `pulumi:"dockerRepository"`
	// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
	EntryPoint pulumi.StringPtrInput `pulumi:"entryPoint"`
	// User-provided build-time environment variables for the function
	EnvironmentVariables pulumi.StringMapInput `pulumi:"environmentVariables"`
	// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
	Runtime pulumi.StringPtrInput `pulumi:"runtime"`
	// The location of the function source code.
	Source SourcePtrInput `pulumi:"source"`
	// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
	SourceToken pulumi.StringPtrInput `pulumi:"sourceToken"`
	// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
	WorkerPool pulumi.StringPtrInput `pulumi:"workerPool"`
}

func (BuildConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*BuildConfig)(nil)).Elem()
}

func (i BuildConfigArgs) ToBuildConfigOutput() BuildConfigOutput {
	return i.ToBuildConfigOutputWithContext(context.Background())
}

func (i BuildConfigArgs) ToBuildConfigOutputWithContext(ctx context.Context) BuildConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildConfigOutput)
}

func (i BuildConfigArgs) ToBuildConfigPtrOutput() BuildConfigPtrOutput {
	return i.ToBuildConfigPtrOutputWithContext(context.Background())
}

func (i BuildConfigArgs) ToBuildConfigPtrOutputWithContext(ctx context.Context) BuildConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildConfigOutput).ToBuildConfigPtrOutputWithContext(ctx)
}

// BuildConfigPtrInput is an input type that accepts BuildConfigArgs, BuildConfigPtr and BuildConfigPtrOutput values.
// You can construct a concrete instance of `BuildConfigPtrInput` via:
//
//	        BuildConfigArgs{...}
//
//	or:
//
//	        nil
type BuildConfigPtrInput interface {
	pulumi.Input

	ToBuildConfigPtrOutput() BuildConfigPtrOutput
	ToBuildConfigPtrOutputWithContext(context.Context) BuildConfigPtrOutput
}

type buildConfigPtrType BuildConfigArgs

func BuildConfigPtr(v *BuildConfigArgs) BuildConfigPtrInput {
	return (*buildConfigPtrType)(v)
}

func (*buildConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**BuildConfig)(nil)).Elem()
}

func (i *buildConfigPtrType) ToBuildConfigPtrOutput() BuildConfigPtrOutput {
	return i.ToBuildConfigPtrOutputWithContext(context.Background())
}

func (i *buildConfigPtrType) ToBuildConfigPtrOutputWithContext(ctx context.Context) BuildConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildConfigPtrOutput)
}

// Describes the Build step of the function that builds a container from the given source.
type BuildConfigOutput struct{ *pulumi.OutputState }

func (BuildConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BuildConfig)(nil)).Elem()
}

func (o BuildConfigOutput) ToBuildConfigOutput() BuildConfigOutput {
	return o
}

func (o BuildConfigOutput) ToBuildConfigOutputWithContext(ctx context.Context) BuildConfigOutput {
	return o
}

func (o BuildConfigOutput) ToBuildConfigPtrOutput() BuildConfigPtrOutput {
	return o.ToBuildConfigPtrOutputWithContext(context.Background())
}

func (o BuildConfigOutput) ToBuildConfigPtrOutputWithContext(ctx context.Context) BuildConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v BuildConfig) *BuildConfig {
		return &v
	}).(BuildConfigPtrOutput)
}

// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
func (o BuildConfigOutput) DockerRegistry() BuildConfigDockerRegistryPtrOutput {
	return o.ApplyT(func(v BuildConfig) *BuildConfigDockerRegistry { return v.DockerRegistry }).(BuildConfigDockerRegistryPtrOutput)
}

// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
func (o BuildConfigOutput) DockerRepository() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildConfig) *string { return v.DockerRepository }).(pulumi.StringPtrOutput)
}

// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
func (o BuildConfigOutput) EntryPoint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildConfig) *string { return v.EntryPoint }).(pulumi.StringPtrOutput)
}

// User-provided build-time environment variables for the function
func (o BuildConfigOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v BuildConfig) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
func (o BuildConfigOutput) Runtime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildConfig) *string { return v.Runtime }).(pulumi.StringPtrOutput)
}

// The location of the function source code.
func (o BuildConfigOutput) Source() SourcePtrOutput {
	return o.ApplyT(func(v BuildConfig) *Source { return v.Source }).(SourcePtrOutput)
}

// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
func (o BuildConfigOutput) SourceToken() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildConfig) *string { return v.SourceToken }).(pulumi.StringPtrOutput)
}

// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
func (o BuildConfigOutput) WorkerPool() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildConfig) *string { return v.WorkerPool }).(pulumi.StringPtrOutput)
}

type BuildConfigPtrOutput struct{ *pulumi.OutputState }

func (BuildConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**BuildConfig)(nil)).Elem()
}

func (o BuildConfigPtrOutput) ToBuildConfigPtrOutput() BuildConfigPtrOutput {
	return o
}

func (o BuildConfigPtrOutput) ToBuildConfigPtrOutputWithContext(ctx context.Context) BuildConfigPtrOutput {
	return o
}

func (o BuildConfigPtrOutput) Elem() BuildConfigOutput {
	return o.ApplyT(func(v *BuildConfig) BuildConfig {
		if v != nil {
			return *v
		}
		var ret BuildConfig
		return ret
	}).(BuildConfigOutput)
}

// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
func (o BuildConfigPtrOutput) DockerRegistry() BuildConfigDockerRegistryPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *BuildConfigDockerRegistry {
		if v == nil {
			return nil
		}
		return v.DockerRegistry
	}).(BuildConfigDockerRegistryPtrOutput)
}

// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
func (o BuildConfigPtrOutput) DockerRepository() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *string {
		if v == nil {
			return nil
		}
		return v.DockerRepository
	}).(pulumi.StringPtrOutput)
}

// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
func (o BuildConfigPtrOutput) EntryPoint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *string {
		if v == nil {
			return nil
		}
		return v.EntryPoint
	}).(pulumi.StringPtrOutput)
}

// User-provided build-time environment variables for the function
func (o BuildConfigPtrOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v *BuildConfig) map[string]string {
		if v == nil {
			return nil
		}
		return v.EnvironmentVariables
	}).(pulumi.StringMapOutput)
}

// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
func (o BuildConfigPtrOutput) Runtime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *string {
		if v == nil {
			return nil
		}
		return v.Runtime
	}).(pulumi.StringPtrOutput)
}

// The location of the function source code.
func (o BuildConfigPtrOutput) Source() SourcePtrOutput {
	return o.ApplyT(func(v *BuildConfig) *Source {
		if v == nil {
			return nil
		}
		return v.Source
	}).(SourcePtrOutput)
}

// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
func (o BuildConfigPtrOutput) SourceToken() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *string {
		if v == nil {
			return nil
		}
		return v.SourceToken
	}).(pulumi.StringPtrOutput)
}

// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
func (o BuildConfigPtrOutput) WorkerPool() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildConfig) *string {
		if v == nil {
			return nil
		}
		return v.WorkerPool
	}).(pulumi.StringPtrOutput)
}

// Describes the Build step of the function that builds a container from the given source.
type BuildConfigResponse struct {
	// The Cloud Build name of the latest successful deployment of the function.
	Build string `pulumi:"build"`
	// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
	DockerRegistry string `pulumi:"dockerRegistry"`
	// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
	DockerRepository string `pulumi:"dockerRepository"`
	// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
	EntryPoint string `pulumi:"entryPoint"`
	// User-provided build-time environment variables for the function
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
	Runtime string `pulumi:"runtime"`
	// The location of the function source code.
	Source SourceResponse `pulumi:"source"`
	// A permanent fixed identifier for source.
	SourceProvenance SourceProvenanceResponse `pulumi:"sourceProvenance"`
	// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
	SourceToken string `pulumi:"sourceToken"`
	// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
	WorkerPool string `pulumi:"workerPool"`
}

// Describes the Build step of the function that builds a container from the given source.
type BuildConfigResponseOutput struct{ *pulumi.OutputState }

func (BuildConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BuildConfigResponse)(nil)).Elem()
}

func (o BuildConfigResponseOutput) ToBuildConfigResponseOutput() BuildConfigResponseOutput {
	return o
}

func (o BuildConfigResponseOutput) ToBuildConfigResponseOutputWithContext(ctx context.Context) BuildConfigResponseOutput {
	return o
}

// The Cloud Build name of the latest successful deployment of the function.
func (o BuildConfigResponseOutput) Build() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.Build }).(pulumi.StringOutput)
}

// Docker Registry to use for this deployment. This configuration is only applicable to 1st Gen functions, 2nd Gen functions can only use Artifact Registry. If `docker_repository` field is specified, this field will be automatically set as `ARTIFACT_REGISTRY`. If unspecified, it currently defaults to `CONTAINER_REGISTRY`. This field may be overridden by the backend for eligible deployments.
func (o BuildConfigResponseOutput) DockerRegistry() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.DockerRegistry }).(pulumi.StringOutput)
}

// User managed repository created in Artifact Registry optionally with a customer managed encryption key. This is the repository to which the function docker image will be pushed after it is built by Cloud Build. If unspecified, GCF will create and use a repository named 'gcf-artifacts' for every deployed region. It must match the pattern `projects/{project}/locations/{location}/repositories/{repository}`. Cross-project repositories are not supported. Cross-location repositories are not supported. Repository format must be 'DOCKER'.
func (o BuildConfigResponseOutput) DockerRepository() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.DockerRepository }).(pulumi.StringOutput)
}

// The name of the function (as defined in source code) that will be executed. Defaults to the resource name suffix, if not specified. For backward compatibility, if function with given name is not found, then the system will try to use function named "function". For Node.js this is name of a function exported by the module specified in `source_location`.
func (o BuildConfigResponseOutput) EntryPoint() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.EntryPoint }).(pulumi.StringOutput)
}

// User-provided build-time environment variables for the function
func (o BuildConfigResponseOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v BuildConfigResponse) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// The runtime in which to run the function. Required when deploying a new function, optional when updating an existing function. For a complete list of possible choices, see the [`gcloud` command reference](https://cloud.google.com/sdk/gcloud/reference/functions/deploy#--runtime).
func (o BuildConfigResponseOutput) Runtime() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.Runtime }).(pulumi.StringOutput)
}

// The location of the function source code.
func (o BuildConfigResponseOutput) Source() SourceResponseOutput {
	return o.ApplyT(func(v BuildConfigResponse) SourceResponse { return v.Source }).(SourceResponseOutput)
}

// A permanent fixed identifier for source.
func (o BuildConfigResponseOutput) SourceProvenance() SourceProvenanceResponseOutput {
	return o.ApplyT(func(v BuildConfigResponse) SourceProvenanceResponse { return v.SourceProvenance }).(SourceProvenanceResponseOutput)
}

// An identifier for Firebase function sources. Disclaimer: This field is only supported for Firebase function deployments.
func (o BuildConfigResponseOutput) SourceToken() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.SourceToken }).(pulumi.StringOutput)
}

// Name of the Cloud Build Custom Worker Pool that should be used to build the function. The format of this field is `projects/{project}/locations/{region}/workerPools/{workerPool}` where {project} and {region} are the project id and region respectively where the worker pool is defined and {workerPool} is the short name of the worker pool. If the project id is not the same as the function, then the Cloud Functions Service Agent (service-@gcf-admin-robot.iam.gserviceaccount.com) must be granted the role Cloud Build Custom Workers Builder (roles/cloudbuild.customworkers.builder) in the project.
func (o BuildConfigResponseOutput) WorkerPool() pulumi.StringOutput {
	return o.ApplyT(func(v BuildConfigResponse) string { return v.WorkerPool }).(pulumi.StringOutput)
}

// Filters events based on exact matches on the CloudEvents attributes.
type EventFilter struct {
	// The name of a CloudEvents attribute.
	Attribute string `pulumi:"attribute"`
	// Optional. The operator used for matching the events with the value of the filter. If not specified, only events that have an exact key-value pair specified in the filter are matched. The only allowed value is `match-path-pattern`.
	Operator *string `pulumi:"operator"`
	// The value for the attribute.
	Value string `pulumi:"value"`
}

// EventFilterInput is an input type that accepts EventFilterArgs and EventFilterOutput values.
// You can construct a concrete instance of `EventFilterInput` via:
//
//	EventFilterArgs{...}
type EventFilterInput interface {
	pulumi.Input

	ToEventFilterOutput() EventFilterOutput
	ToEventFilterOutputWithContext(context.Context) EventFilterOutput
}

// Filters events based on exact matches on the CloudEvents attributes.
type EventFilterArgs struct {
	// The name of a CloudEvents attribute.
	Attribute pulumi.StringInput `pulumi:"attribute"`
	// Optional. The operator used for matching the events with the value of the filter. If not specified, only events that have an exact key-value pair specified in the filter are matched. The only allowed value is `match-path-pattern`.
	Operator pulumi.StringPtrInput `pulumi:"operator"`
	// The value for the attribute.
	Value pulumi.StringInput `pulumi:"value"`
}

func (EventFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EventFilter)(nil)).Elem()
}

func (i EventFilterArgs) ToEventFilterOutput() EventFilterOutput {
	return i.ToEventFilterOutputWithContext(context.Background())
}

func (i EventFilterArgs) ToEventFilterOutputWithContext(ctx context.Context) EventFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventFilterOutput)
}

// EventFilterArrayInput is an input type that accepts EventFilterArray and EventFilterArrayOutput values.
// You can construct a concrete instance of `EventFilterArrayInput` via:
//
//	EventFilterArray{ EventFilterArgs{...} }
type EventFilterArrayInput interface {
	pulumi.Input

	ToEventFilterArrayOutput() EventFilterArrayOutput
	ToEventFilterArrayOutputWithContext(context.Context) EventFilterArrayOutput
}

type EventFilterArray []EventFilterInput

func (EventFilterArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EventFilter)(nil)).Elem()
}

func (i EventFilterArray) ToEventFilterArrayOutput() EventFilterArrayOutput {
	return i.ToEventFilterArrayOutputWithContext(context.Background())
}

func (i EventFilterArray) ToEventFilterArrayOutputWithContext(ctx context.Context) EventFilterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventFilterArrayOutput)
}

// Filters events based on exact matches on the CloudEvents attributes.
type EventFilterOutput struct{ *pulumi.OutputState }

func (EventFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EventFilter)(nil)).Elem()
}

func (o EventFilterOutput) ToEventFilterOutput() EventFilterOutput {
	return o
}

func (o EventFilterOutput) ToEventFilterOutputWithContext(ctx context.Context) EventFilterOutput {
	return o
}

// The name of a CloudEvents attribute.
func (o EventFilterOutput) Attribute() pulumi.StringOutput {
	return o.ApplyT(func(v EventFilter) string { return v.Attribute }).(pulumi.StringOutput)
}

// Optional. The operator used for matching the events with the value of the filter. If not specified, only events that have an exact key-value pair specified in the filter are matched. The only allowed value is `match-path-pattern`.
func (o EventFilterOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EventFilter) *string { return v.Operator }).(pulumi.StringPtrOutput)
}

// The value for the attribute.
func (o EventFilterOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v EventFilter) string { return v.Value }).(pulumi.StringOutput)
}

type EventFilterArrayOutput struct{ *pulumi.OutputState }

func (EventFilterArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EventFilter)(nil)).Elem()
}

func (o EventFilterArrayOutput) ToEventFilterArrayOutput() EventFilterArrayOutput {
	return o
}

func (o EventFilterArrayOutput) ToEventFilterArrayOutputWithContext(ctx context.Context) EventFilterArrayOutput {
	return o
}

func (o EventFilterArrayOutput) Index(i pulumi.IntInput) EventFilterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EventFilter {
		return vs[0].([]EventFilter)[vs[1].(int)]
	}).(EventFilterOutput)
}

// Filters events based on exact matches on the CloudEvents attributes.
type EventFilterResponse struct {
	// The name of a CloudEvents attribute.
	Attribute string `pulumi:"attribute"`
	// Optional. The operator used for matching the events with the value of the filter. If not specified, only events that have an exact key-value pair specified in the filter are matched. The only allowed value is `match-path-pattern`.
	Operator string `pulumi:"operator"`
	// The value for the attribute.
	Value string `pulumi:"value"`
}

// Filters events based on exact matches on the CloudEvents attributes.
type EventFilterResponseOutput struct{ *pulumi.OutputState }

func (EventFilterResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EventFilterResponse)(nil)).Elem()
}

func (o EventFilterResponseOutput) ToEventFilterResponseOutput() EventFilterResponseOutput {
	return o
}

func (o EventFilterResponseOutput) ToEventFilterResponseOutputWithContext(ctx context.Context) EventFilterResponseOutput {
	return o
}

// The name of a CloudEvents attribute.
func (o EventFilterResponseOutput) Attribute() pulumi.StringOutput {
	return o.ApplyT(func(v EventFilterResponse) string { return v.Attribute }).(pulumi.StringOutput)
}

// Optional. The operator used for matching the events with the value of the filter. If not specified, only events that have an exact key-value pair specified in the filter are matched. The only allowed value is `match-path-pattern`.
func (o EventFilterResponseOutput) Operator() pulumi.StringOutput {
	return o.ApplyT(func(v EventFilterResponse) string { return v.Operator }).(pulumi.StringOutput)
}

// The value for the attribute.
func (o EventFilterResponseOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v EventFilterResponse) string { return v.Value }).(pulumi.StringOutput)
}

type EventFilterResponseArrayOutput struct{ *pulumi.OutputState }

func (EventFilterResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EventFilterResponse)(nil)).Elem()
}

func (o EventFilterResponseArrayOutput) ToEventFilterResponseArrayOutput() EventFilterResponseArrayOutput {
	return o
}

func (o EventFilterResponseArrayOutput) ToEventFilterResponseArrayOutputWithContext(ctx context.Context) EventFilterResponseArrayOutput {
	return o
}

func (o EventFilterResponseArrayOutput) Index(i pulumi.IntInput) EventFilterResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EventFilterResponse {
		return vs[0].([]EventFilterResponse)[vs[1].(int)]
	}).(EventFilterResponseOutput)
}

// Describes EventTrigger, used to request events to be sent from another service.
type EventTrigger struct {
	// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
	Channel *string `pulumi:"channel"`
	// Criteria used to filter events.
	EventFilters []EventFilter `pulumi:"eventFilters"`
	// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
	EventType string `pulumi:"eventType"`
	// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
	PubsubTopic *string `pulumi:"pubsubTopic"`
	// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
	RetryPolicy *EventTriggerRetryPolicy `pulumi:"retryPolicy"`
	// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail *string `pulumi:"serviceAccountEmail"`
	// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
	TriggerRegion *string `pulumi:"triggerRegion"`
}

// EventTriggerInput is an input type that accepts EventTriggerArgs and EventTriggerOutput values.
// You can construct a concrete instance of `EventTriggerInput` via:
//
//	EventTriggerArgs{...}
type EventTriggerInput interface {
	pulumi.Input

	ToEventTriggerOutput() EventTriggerOutput
	ToEventTriggerOutputWithContext(context.Context) EventTriggerOutput
}

// Describes EventTrigger, used to request events to be sent from another service.
type EventTriggerArgs struct {
	// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
	Channel pulumi.StringPtrInput `pulumi:"channel"`
	// Criteria used to filter events.
	EventFilters EventFilterArrayInput `pulumi:"eventFilters"`
	// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
	EventType pulumi.StringInput `pulumi:"eventType"`
	// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
	PubsubTopic pulumi.StringPtrInput `pulumi:"pubsubTopic"`
	// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
	RetryPolicy EventTriggerRetryPolicyPtrInput `pulumi:"retryPolicy"`
	// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail pulumi.StringPtrInput `pulumi:"serviceAccountEmail"`
	// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
	TriggerRegion pulumi.StringPtrInput `pulumi:"triggerRegion"`
}

func (EventTriggerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EventTrigger)(nil)).Elem()
}

func (i EventTriggerArgs) ToEventTriggerOutput() EventTriggerOutput {
	return i.ToEventTriggerOutputWithContext(context.Background())
}

func (i EventTriggerArgs) ToEventTriggerOutputWithContext(ctx context.Context) EventTriggerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventTriggerOutput)
}

func (i EventTriggerArgs) ToEventTriggerPtrOutput() EventTriggerPtrOutput {
	return i.ToEventTriggerPtrOutputWithContext(context.Background())
}

func (i EventTriggerArgs) ToEventTriggerPtrOutputWithContext(ctx context.Context) EventTriggerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventTriggerOutput).ToEventTriggerPtrOutputWithContext(ctx)
}

// EventTriggerPtrInput is an input type that accepts EventTriggerArgs, EventTriggerPtr and EventTriggerPtrOutput values.
// You can construct a concrete instance of `EventTriggerPtrInput` via:
//
//	        EventTriggerArgs{...}
//
//	or:
//
//	        nil
type EventTriggerPtrInput interface {
	pulumi.Input

	ToEventTriggerPtrOutput() EventTriggerPtrOutput
	ToEventTriggerPtrOutputWithContext(context.Context) EventTriggerPtrOutput
}

type eventTriggerPtrType EventTriggerArgs

func EventTriggerPtr(v *EventTriggerArgs) EventTriggerPtrInput {
	return (*eventTriggerPtrType)(v)
}

func (*eventTriggerPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EventTrigger)(nil)).Elem()
}

func (i *eventTriggerPtrType) ToEventTriggerPtrOutput() EventTriggerPtrOutput {
	return i.ToEventTriggerPtrOutputWithContext(context.Background())
}

func (i *eventTriggerPtrType) ToEventTriggerPtrOutputWithContext(ctx context.Context) EventTriggerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventTriggerPtrOutput)
}

// Describes EventTrigger, used to request events to be sent from another service.
type EventTriggerOutput struct{ *pulumi.OutputState }

func (EventTriggerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EventTrigger)(nil)).Elem()
}

func (o EventTriggerOutput) ToEventTriggerOutput() EventTriggerOutput {
	return o
}

func (o EventTriggerOutput) ToEventTriggerOutputWithContext(ctx context.Context) EventTriggerOutput {
	return o
}

func (o EventTriggerOutput) ToEventTriggerPtrOutput() EventTriggerPtrOutput {
	return o.ToEventTriggerPtrOutputWithContext(context.Background())
}

func (o EventTriggerOutput) ToEventTriggerPtrOutputWithContext(ctx context.Context) EventTriggerPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EventTrigger) *EventTrigger {
		return &v
	}).(EventTriggerPtrOutput)
}

// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
func (o EventTriggerOutput) Channel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EventTrigger) *string { return v.Channel }).(pulumi.StringPtrOutput)
}

// Criteria used to filter events.
func (o EventTriggerOutput) EventFilters() EventFilterArrayOutput {
	return o.ApplyT(func(v EventTrigger) []EventFilter { return v.EventFilters }).(EventFilterArrayOutput)
}

// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
func (o EventTriggerOutput) EventType() pulumi.StringOutput {
	return o.ApplyT(func(v EventTrigger) string { return v.EventType }).(pulumi.StringOutput)
}

// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
func (o EventTriggerOutput) PubsubTopic() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EventTrigger) *string { return v.PubsubTopic }).(pulumi.StringPtrOutput)
}

// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
func (o EventTriggerOutput) RetryPolicy() EventTriggerRetryPolicyPtrOutput {
	return o.ApplyT(func(v EventTrigger) *EventTriggerRetryPolicy { return v.RetryPolicy }).(EventTriggerRetryPolicyPtrOutput)
}

// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
func (o EventTriggerOutput) ServiceAccountEmail() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EventTrigger) *string { return v.ServiceAccountEmail }).(pulumi.StringPtrOutput)
}

// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
func (o EventTriggerOutput) TriggerRegion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EventTrigger) *string { return v.TriggerRegion }).(pulumi.StringPtrOutput)
}

type EventTriggerPtrOutput struct{ *pulumi.OutputState }

func (EventTriggerPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EventTrigger)(nil)).Elem()
}

func (o EventTriggerPtrOutput) ToEventTriggerPtrOutput() EventTriggerPtrOutput {
	return o
}

func (o EventTriggerPtrOutput) ToEventTriggerPtrOutputWithContext(ctx context.Context) EventTriggerPtrOutput {
	return o
}

func (o EventTriggerPtrOutput) Elem() EventTriggerOutput {
	return o.ApplyT(func(v *EventTrigger) EventTrigger {
		if v != nil {
			return *v
		}
		var ret EventTrigger
		return ret
	}).(EventTriggerOutput)
}

// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
func (o EventTriggerPtrOutput) Channel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *string {
		if v == nil {
			return nil
		}
		return v.Channel
	}).(pulumi.StringPtrOutput)
}

// Criteria used to filter events.
func (o EventTriggerPtrOutput) EventFilters() EventFilterArrayOutput {
	return o.ApplyT(func(v *EventTrigger) []EventFilter {
		if v == nil {
			return nil
		}
		return v.EventFilters
	}).(EventFilterArrayOutput)
}

// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
func (o EventTriggerPtrOutput) EventType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *string {
		if v == nil {
			return nil
		}
		return &v.EventType
	}).(pulumi.StringPtrOutput)
}

// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
func (o EventTriggerPtrOutput) PubsubTopic() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *string {
		if v == nil {
			return nil
		}
		return v.PubsubTopic
	}).(pulumi.StringPtrOutput)
}

// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
func (o EventTriggerPtrOutput) RetryPolicy() EventTriggerRetryPolicyPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *EventTriggerRetryPolicy {
		if v == nil {
			return nil
		}
		return v.RetryPolicy
	}).(EventTriggerRetryPolicyPtrOutput)
}

// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
func (o EventTriggerPtrOutput) ServiceAccountEmail() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *string {
		if v == nil {
			return nil
		}
		return v.ServiceAccountEmail
	}).(pulumi.StringPtrOutput)
}

// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
func (o EventTriggerPtrOutput) TriggerRegion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventTrigger) *string {
		if v == nil {
			return nil
		}
		return v.TriggerRegion
	}).(pulumi.StringPtrOutput)
}

// Describes EventTrigger, used to request events to be sent from another service.
type EventTriggerResponse struct {
	// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
	Channel string `pulumi:"channel"`
	// Criteria used to filter events.
	EventFilters []EventFilterResponse `pulumi:"eventFilters"`
	// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
	EventType string `pulumi:"eventType"`
	// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
	PubsubTopic string `pulumi:"pubsubTopic"`
	// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
	RetryPolicy string `pulumi:"retryPolicy"`
	// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail string `pulumi:"serviceAccountEmail"`
	// The resource name of the Eventarc trigger. The format of this field is `projects/{project}/locations/{region}/triggers/{trigger}`.
	Trigger string `pulumi:"trigger"`
	// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
	TriggerRegion string `pulumi:"triggerRegion"`
}

// Describes EventTrigger, used to request events to be sent from another service.
type EventTriggerResponseOutput struct{ *pulumi.OutputState }

func (EventTriggerResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EventTriggerResponse)(nil)).Elem()
}

func (o EventTriggerResponseOutput) ToEventTriggerResponseOutput() EventTriggerResponseOutput {
	return o
}

func (o EventTriggerResponseOutput) ToEventTriggerResponseOutputWithContext(ctx context.Context) EventTriggerResponseOutput {
	return o
}

// Optional. The name of the channel associated with the trigger in `projects/{project}/locations/{location}/channels/{channel}` format. You must provide a channel to receive events from Eventarc SaaS partners.
func (o EventTriggerResponseOutput) Channel() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.Channel }).(pulumi.StringOutput)
}

// Criteria used to filter events.
func (o EventTriggerResponseOutput) EventFilters() EventFilterResponseArrayOutput {
	return o.ApplyT(func(v EventTriggerResponse) []EventFilterResponse { return v.EventFilters }).(EventFilterResponseArrayOutput)
}

// The type of event to observe. For example: `google.cloud.audit.log.v1.written` or `google.cloud.pubsub.topic.v1.messagePublished`.
func (o EventTriggerResponseOutput) EventType() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.EventType }).(pulumi.StringOutput)
}

// Optional. The name of a Pub/Sub topic in the same project that will be used as the transport topic for the event delivery. Format: `projects/{project}/topics/{topic}`. This is only valid for events of type `google.cloud.pubsub.topic.v1.messagePublished`. The topic provided here will not be deleted at function deletion.
func (o EventTriggerResponseOutput) PubsubTopic() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.PubsubTopic }).(pulumi.StringOutput)
}

// Optional. If unset, then defaults to ignoring failures (i.e. not retrying them).
func (o EventTriggerResponseOutput) RetryPolicy() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.RetryPolicy }).(pulumi.StringOutput)
}

// Optional. The email of the trigger's service account. The service account must have permission to invoke Cloud Run services, the permission is `run.routes.invoke`. If empty, defaults to the Compute Engine default service account: `{project_number}-compute@developer.gserviceaccount.com`.
func (o EventTriggerResponseOutput) ServiceAccountEmail() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.ServiceAccountEmail }).(pulumi.StringOutput)
}

// The resource name of the Eventarc trigger. The format of this field is `projects/{project}/locations/{region}/triggers/{trigger}`.
func (o EventTriggerResponseOutput) Trigger() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.Trigger }).(pulumi.StringOutput)
}

// The region that the trigger will be in. The trigger will only receive events originating in this region. It can be the same region as the function, a different region or multi-region, or the global region. If not provided, defaults to the same region as the function.
func (o EventTriggerResponseOutput) TriggerRegion() pulumi.StringOutput {
	return o.ApplyT(func(v EventTriggerResponse) string { return v.TriggerRegion }).(pulumi.StringOutput)
}

// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
type Expr struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description *string `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression *string `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location *string `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title *string `pulumi:"title"`
}

// ExprInput is an input type that accepts ExprArgs and ExprOutput values.
// You can construct a concrete instance of `ExprInput` via:
//
//	ExprArgs{...}
type ExprInput interface {
	pulumi.Input

	ToExprOutput() ExprOutput
	ToExprOutputWithContext(context.Context) ExprOutput
}

// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
type ExprArgs struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression pulumi.StringPtrInput `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location pulumi.StringPtrInput `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title pulumi.StringPtrInput `pulumi:"title"`
}

func (ExprArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Expr)(nil)).Elem()
}

func (i ExprArgs) ToExprOutput() ExprOutput {
	return i.ToExprOutputWithContext(context.Background())
}

func (i ExprArgs) ToExprOutputWithContext(ctx context.Context) ExprOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ExprOutput)
}

func (i ExprArgs) ToExprPtrOutput() ExprPtrOutput {
	return i.ToExprPtrOutputWithContext(context.Background())
}

func (i ExprArgs) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ExprOutput).ToExprPtrOutputWithContext(ctx)
}

// ExprPtrInput is an input type that accepts ExprArgs, ExprPtr and ExprPtrOutput values.
// You can construct a concrete instance of `ExprPtrInput` via:
//
//	        ExprArgs{...}
//
//	or:
//
//	        nil
type ExprPtrInput interface {
	pulumi.Input

	ToExprPtrOutput() ExprPtrOutput
	ToExprPtrOutputWithContext(context.Context) ExprPtrOutput
}

type exprPtrType ExprArgs

func ExprPtr(v *ExprArgs) ExprPtrInput {
	return (*exprPtrType)(v)
}

func (*exprPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Expr)(nil)).Elem()
}

func (i *exprPtrType) ToExprPtrOutput() ExprPtrOutput {
	return i.ToExprPtrOutputWithContext(context.Background())
}

func (i *exprPtrType) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ExprPtrOutput)
}

// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
type ExprOutput struct{ *pulumi.OutputState }

func (ExprOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Expr)(nil)).Elem()
}

func (o ExprOutput) ToExprOutput() ExprOutput {
	return o
}

func (o ExprOutput) ToExprOutputWithContext(ctx context.Context) ExprOutput {
	return o
}

func (o ExprOutput) ToExprPtrOutput() ExprPtrOutput {
	return o.ToExprPtrOutputWithContext(context.Background())
}

func (o ExprOutput) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Expr) *Expr {
		return &v
	}).(ExprPtrOutput)
}

// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
func (o ExprOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Expr) *string { return v.Description }).(pulumi.StringPtrOutput)
}

// Textual representation of an expression in Common Expression Language syntax.
func (o ExprOutput) Expression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Expr) *string { return v.Expression }).(pulumi.StringPtrOutput)
}

// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
func (o ExprOutput) Location() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Expr) *string { return v.Location }).(pulumi.StringPtrOutput)
}

// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
func (o ExprOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Expr) *string { return v.Title }).(pulumi.StringPtrOutput)
}

type ExprPtrOutput struct{ *pulumi.OutputState }

func (ExprPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Expr)(nil)).Elem()
}

func (o ExprPtrOutput) ToExprPtrOutput() ExprPtrOutput {
	return o
}

func (o ExprPtrOutput) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput {
	return o
}

func (o ExprPtrOutput) Elem() ExprOutput {
	return o.ApplyT(func(v *Expr) Expr {
		if v != nil {
			return *v
		}
		var ret Expr
		return ret
	}).(ExprOutput)
}

// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
func (o ExprPtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Expr) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

// Textual representation of an expression in Common Expression Language syntax.
func (o ExprPtrOutput) Expression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Expr) *string {
		if v == nil {
			return nil
		}
		return v.Expression
	}).(pulumi.StringPtrOutput)
}

// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
func (o ExprPtrOutput) Location() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Expr) *string {
		if v == nil {
			return nil
		}
		return v.Location
	}).(pulumi.StringPtrOutput)
}

// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
func (o ExprPtrOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Expr) *string {
		if v == nil {
			return nil
		}
		return v.Title
	}).(pulumi.StringPtrOutput)
}

// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
type ExprResponse struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description string `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression string `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location string `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title string `pulumi:"title"`
}

// Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
type ExprResponseOutput struct{ *pulumi.OutputState }

func (ExprResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ExprResponse)(nil)).Elem()
}

func (o ExprResponseOutput) ToExprResponseOutput() ExprResponseOutput {
	return o
}

func (o ExprResponseOutput) ToExprResponseOutputWithContext(ctx context.Context) ExprResponseOutput {
	return o
}

// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
func (o ExprResponseOutput) Description() pulumi.StringOutput {
	return o.ApplyT(func(v ExprResponse) string { return v.Description }).(pulumi.StringOutput)
}

// Textual representation of an expression in Common Expression Language syntax.
func (o ExprResponseOutput) Expression() pulumi.StringOutput {
	return o.ApplyT(func(v ExprResponse) string { return v.Expression }).(pulumi.StringOutput)
}

// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
func (o ExprResponseOutput) Location() pulumi.StringOutput {
	return o.ApplyT(func(v ExprResponse) string { return v.Location }).(pulumi.StringOutput)
}

// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
func (o ExprResponseOutput) Title() pulumi.StringOutput {
	return o.ApplyT(func(v ExprResponse) string { return v.Title }).(pulumi.StringOutput)
}

// Informational messages about the state of the Cloud Function or Operation.
type GoogleCloudFunctionsV2betaStateMessageResponse struct {
	// The message.
	Message string `pulumi:"message"`
	// Severity of the state message.
	Severity string `pulumi:"severity"`
	// One-word CamelCase type of the state message.
	Type string `pulumi:"type"`
}

// Informational messages about the state of the Cloud Function or Operation.
type GoogleCloudFunctionsV2betaStateMessageResponseOutput struct{ *pulumi.OutputState }

func (GoogleCloudFunctionsV2betaStateMessageResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GoogleCloudFunctionsV2betaStateMessageResponse)(nil)).Elem()
}

func (o GoogleCloudFunctionsV2betaStateMessageResponseOutput) ToGoogleCloudFunctionsV2betaStateMessageResponseOutput() GoogleCloudFunctionsV2betaStateMessageResponseOutput {
	return o
}

func (o GoogleCloudFunctionsV2betaStateMessageResponseOutput) ToGoogleCloudFunctionsV2betaStateMessageResponseOutputWithContext(ctx context.Context) GoogleCloudFunctionsV2betaStateMessageResponseOutput {
	return o
}

// The message.
func (o GoogleCloudFunctionsV2betaStateMessageResponseOutput) Message() pulumi.StringOutput {
	return o.ApplyT(func(v GoogleCloudFunctionsV2betaStateMessageResponse) string { return v.Message }).(pulumi.StringOutput)
}

// Severity of the state message.
func (o GoogleCloudFunctionsV2betaStateMessageResponseOutput) Severity() pulumi.StringOutput {
	return o.ApplyT(func(v GoogleCloudFunctionsV2betaStateMessageResponse) string { return v.Severity }).(pulumi.StringOutput)
}

// One-word CamelCase type of the state message.
func (o GoogleCloudFunctionsV2betaStateMessageResponseOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v GoogleCloudFunctionsV2betaStateMessageResponse) string { return v.Type }).(pulumi.StringOutput)
}

type GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput struct{ *pulumi.OutputState }

func (GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GoogleCloudFunctionsV2betaStateMessageResponse)(nil)).Elem()
}

func (o GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput) ToGoogleCloudFunctionsV2betaStateMessageResponseArrayOutput() GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput {
	return o
}

func (o GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput) ToGoogleCloudFunctionsV2betaStateMessageResponseArrayOutputWithContext(ctx context.Context) GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput {
	return o
}

func (o GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput) Index(i pulumi.IntInput) GoogleCloudFunctionsV2betaStateMessageResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GoogleCloudFunctionsV2betaStateMessageResponse {
		return vs[0].([]GoogleCloudFunctionsV2betaStateMessageResponse)[vs[1].(int)]
	}).(GoogleCloudFunctionsV2betaStateMessageResponseOutput)
}

// Location of the source in a Google Cloud Source Repository.
type RepoSource struct {
	// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	BranchName *string `pulumi:"branchName"`
	// Explicit commit SHA to build.
	CommitSha *string `pulumi:"commitSha"`
	// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
	Dir *string `pulumi:"dir"`
	// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
	Project *string `pulumi:"project"`
	// Name of the Cloud Source Repository.
	RepoName *string `pulumi:"repoName"`
	// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	TagName *string `pulumi:"tagName"`
}

// RepoSourceInput is an input type that accepts RepoSourceArgs and RepoSourceOutput values.
// You can construct a concrete instance of `RepoSourceInput` via:
//
//	RepoSourceArgs{...}
type RepoSourceInput interface {
	pulumi.Input

	ToRepoSourceOutput() RepoSourceOutput
	ToRepoSourceOutputWithContext(context.Context) RepoSourceOutput
}

// Location of the source in a Google Cloud Source Repository.
type RepoSourceArgs struct {
	// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	BranchName pulumi.StringPtrInput `pulumi:"branchName"`
	// Explicit commit SHA to build.
	CommitSha pulumi.StringPtrInput `pulumi:"commitSha"`
	// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
	Dir pulumi.StringPtrInput `pulumi:"dir"`
	// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
	Project pulumi.StringPtrInput `pulumi:"project"`
	// Name of the Cloud Source Repository.
	RepoName pulumi.StringPtrInput `pulumi:"repoName"`
	// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	TagName pulumi.StringPtrInput `pulumi:"tagName"`
}

func (RepoSourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RepoSource)(nil)).Elem()
}

func (i RepoSourceArgs) ToRepoSourceOutput() RepoSourceOutput {
	return i.ToRepoSourceOutputWithContext(context.Background())
}

func (i RepoSourceArgs) ToRepoSourceOutputWithContext(ctx context.Context) RepoSourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepoSourceOutput)
}

func (i RepoSourceArgs) ToRepoSourcePtrOutput() RepoSourcePtrOutput {
	return i.ToRepoSourcePtrOutputWithContext(context.Background())
}

func (i RepoSourceArgs) ToRepoSourcePtrOutputWithContext(ctx context.Context) RepoSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepoSourceOutput).ToRepoSourcePtrOutputWithContext(ctx)
}

// RepoSourcePtrInput is an input type that accepts RepoSourceArgs, RepoSourcePtr and RepoSourcePtrOutput values.
// You can construct a concrete instance of `RepoSourcePtrInput` via:
//
//	        RepoSourceArgs{...}
//
//	or:
//
//	        nil
type RepoSourcePtrInput interface {
	pulumi.Input

	ToRepoSourcePtrOutput() RepoSourcePtrOutput
	ToRepoSourcePtrOutputWithContext(context.Context) RepoSourcePtrOutput
}

type repoSourcePtrType RepoSourceArgs

func RepoSourcePtr(v *RepoSourceArgs) RepoSourcePtrInput {
	return (*repoSourcePtrType)(v)
}

func (*repoSourcePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RepoSource)(nil)).Elem()
}

func (i *repoSourcePtrType) ToRepoSourcePtrOutput() RepoSourcePtrOutput {
	return i.ToRepoSourcePtrOutputWithContext(context.Background())
}

func (i *repoSourcePtrType) ToRepoSourcePtrOutputWithContext(ctx context.Context) RepoSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepoSourcePtrOutput)
}

// Location of the source in a Google Cloud Source Repository.
type RepoSourceOutput struct{ *pulumi.OutputState }

func (RepoSourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RepoSource)(nil)).Elem()
}

func (o RepoSourceOutput) ToRepoSourceOutput() RepoSourceOutput {
	return o
}

func (o RepoSourceOutput) ToRepoSourceOutputWithContext(ctx context.Context) RepoSourceOutput {
	return o
}

func (o RepoSourceOutput) ToRepoSourcePtrOutput() RepoSourcePtrOutput {
	return o.ToRepoSourcePtrOutputWithContext(context.Background())
}

func (o RepoSourceOutput) ToRepoSourcePtrOutputWithContext(ctx context.Context) RepoSourcePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RepoSource) *RepoSource {
		return &v
	}).(RepoSourcePtrOutput)
}

// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourceOutput) BranchName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.BranchName }).(pulumi.StringPtrOutput)
}

// Explicit commit SHA to build.
func (o RepoSourceOutput) CommitSha() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.CommitSha }).(pulumi.StringPtrOutput)
}

// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
func (o RepoSourceOutput) Dir() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.Dir }).(pulumi.StringPtrOutput)
}

// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
func (o RepoSourceOutput) Project() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.Project }).(pulumi.StringPtrOutput)
}

// Name of the Cloud Source Repository.
func (o RepoSourceOutput) RepoName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.RepoName }).(pulumi.StringPtrOutput)
}

// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourceOutput) TagName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RepoSource) *string { return v.TagName }).(pulumi.StringPtrOutput)
}

type RepoSourcePtrOutput struct{ *pulumi.OutputState }

func (RepoSourcePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RepoSource)(nil)).Elem()
}

func (o RepoSourcePtrOutput) ToRepoSourcePtrOutput() RepoSourcePtrOutput {
	return o
}

func (o RepoSourcePtrOutput) ToRepoSourcePtrOutputWithContext(ctx context.Context) RepoSourcePtrOutput {
	return o
}

func (o RepoSourcePtrOutput) Elem() RepoSourceOutput {
	return o.ApplyT(func(v *RepoSource) RepoSource {
		if v != nil {
			return *v
		}
		var ret RepoSource
		return ret
	}).(RepoSourceOutput)
}

// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourcePtrOutput) BranchName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.BranchName
	}).(pulumi.StringPtrOutput)
}

// Explicit commit SHA to build.
func (o RepoSourcePtrOutput) CommitSha() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.CommitSha
	}).(pulumi.StringPtrOutput)
}

// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
func (o RepoSourcePtrOutput) Dir() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.Dir
	}).(pulumi.StringPtrOutput)
}

// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
func (o RepoSourcePtrOutput) Project() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.Project
	}).(pulumi.StringPtrOutput)
}

// Name of the Cloud Source Repository.
func (o RepoSourcePtrOutput) RepoName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.RepoName
	}).(pulumi.StringPtrOutput)
}

// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourcePtrOutput) TagName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepoSource) *string {
		if v == nil {
			return nil
		}
		return v.TagName
	}).(pulumi.StringPtrOutput)
}

// Location of the source in a Google Cloud Source Repository.
type RepoSourceResponse struct {
	// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	BranchName string `pulumi:"branchName"`
	// Explicit commit SHA to build.
	CommitSha string `pulumi:"commitSha"`
	// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
	Dir string `pulumi:"dir"`
	// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
	Project string `pulumi:"project"`
	// Name of the Cloud Source Repository.
	RepoName string `pulumi:"repoName"`
	// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
	TagName string `pulumi:"tagName"`
}

// Location of the source in a Google Cloud Source Repository.
type RepoSourceResponseOutput struct{ *pulumi.OutputState }

func (RepoSourceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RepoSourceResponse)(nil)).Elem()
}

func (o RepoSourceResponseOutput) ToRepoSourceResponseOutput() RepoSourceResponseOutput {
	return o
}

func (o RepoSourceResponseOutput) ToRepoSourceResponseOutputWithContext(ctx context.Context) RepoSourceResponseOutput {
	return o
}

// Regex matching branches to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourceResponseOutput) BranchName() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.BranchName }).(pulumi.StringOutput)
}

// Explicit commit SHA to build.
func (o RepoSourceResponseOutput) CommitSha() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.CommitSha }).(pulumi.StringOutput)
}

// Directory, relative to the source root, in which to run the build. This must be a relative path. If a step's `dir` is specified and is an absolute path, this value is ignored for that step's execution. eg. helloworld (no leading slash allowed)
func (o RepoSourceResponseOutput) Dir() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.Dir }).(pulumi.StringOutput)
}

// ID of the project that owns the Cloud Source Repository. If omitted, the project ID requesting the build is assumed.
func (o RepoSourceResponseOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.Project }).(pulumi.StringOutput)
}

// Name of the Cloud Source Repository.
func (o RepoSourceResponseOutput) RepoName() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.RepoName }).(pulumi.StringOutput)
}

// Regex matching tags to build. The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
func (o RepoSourceResponseOutput) TagName() pulumi.StringOutput {
	return o.ApplyT(func(v RepoSourceResponse) string { return v.TagName }).(pulumi.StringOutput)
}

// Configuration for a secret environment variable. It has the information necessary to fetch the secret value from secret manager and expose it as an environment variable.
type SecretEnvVar struct {
	// Name of the environment variable.
	Key *string `pulumi:"key"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project *string `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret *string `pulumi:"secret"`
	// Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
	Version *string `pulumi:"version"`
}

// SecretEnvVarInput is an input type that accepts SecretEnvVarArgs and SecretEnvVarOutput values.
// You can construct a concrete instance of `SecretEnvVarInput` via:
//
//	SecretEnvVarArgs{...}
type SecretEnvVarInput interface {
	pulumi.Input

	ToSecretEnvVarOutput() SecretEnvVarOutput
	ToSecretEnvVarOutputWithContext(context.Context) SecretEnvVarOutput
}

// Configuration for a secret environment variable. It has the information necessary to fetch the secret value from secret manager and expose it as an environment variable.
type SecretEnvVarArgs struct {
	// Name of the environment variable.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project pulumi.StringPtrInput `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret pulumi.StringPtrInput `pulumi:"secret"`
	// Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (SecretEnvVarArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretEnvVar)(nil)).Elem()
}

func (i SecretEnvVarArgs) ToSecretEnvVarOutput() SecretEnvVarOutput {
	return i.ToSecretEnvVarOutputWithContext(context.Background())
}

func (i SecretEnvVarArgs) ToSecretEnvVarOutputWithContext(ctx context.Context) SecretEnvVarOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretEnvVarOutput)
}

// SecretEnvVarArrayInput is an input type that accepts SecretEnvVarArray and SecretEnvVarArrayOutput values.
// You can construct a concrete instance of `SecretEnvVarArrayInput` via:
//
//	SecretEnvVarArray{ SecretEnvVarArgs{...} }
type SecretEnvVarArrayInput interface {
	pulumi.Input

	ToSecretEnvVarArrayOutput() SecretEnvVarArrayOutput
	ToSecretEnvVarArrayOutputWithContext(context.Context) SecretEnvVarArrayOutput
}

type SecretEnvVarArray []SecretEnvVarInput

func (SecretEnvVarArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretEnvVar)(nil)).Elem()
}

func (i SecretEnvVarArray) ToSecretEnvVarArrayOutput() SecretEnvVarArrayOutput {
	return i.ToSecretEnvVarArrayOutputWithContext(context.Background())
}

func (i SecretEnvVarArray) ToSecretEnvVarArrayOutputWithContext(ctx context.Context) SecretEnvVarArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretEnvVarArrayOutput)
}

// Configuration for a secret environment variable. It has the information necessary to fetch the secret value from secret manager and expose it as an environment variable.
type SecretEnvVarOutput struct{ *pulumi.OutputState }

func (SecretEnvVarOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretEnvVar)(nil)).Elem()
}

func (o SecretEnvVarOutput) ToSecretEnvVarOutput() SecretEnvVarOutput {
	return o
}

func (o SecretEnvVarOutput) ToSecretEnvVarOutputWithContext(ctx context.Context) SecretEnvVarOutput {
	return o
}

// Name of the environment variable.
func (o SecretEnvVarOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretEnvVar) *string { return v.Key }).(pulumi.StringPtrOutput)
}

// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
func (o SecretEnvVarOutput) Project() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretEnvVar) *string { return v.Project }).(pulumi.StringPtrOutput)
}

// Name of the secret in secret manager (not the full resource name).
func (o SecretEnvVarOutput) Secret() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretEnvVar) *string { return v.Secret }).(pulumi.StringPtrOutput)
}

// Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
func (o SecretEnvVarOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretEnvVar) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type SecretEnvVarArrayOutput struct{ *pulumi.OutputState }

func (SecretEnvVarArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretEnvVar)(nil)).Elem()
}

func (o SecretEnvVarArrayOutput) ToSecretEnvVarArrayOutput() SecretEnvVarArrayOutput {
	return o
}

func (o SecretEnvVarArrayOutput) ToSecretEnvVarArrayOutputWithContext(ctx context.Context) SecretEnvVarArrayOutput {
	return o
}

func (o SecretEnvVarArrayOutput) Index(i pulumi.IntInput) SecretEnvVarOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretEnvVar {
		return vs[0].([]SecretEnvVar)[vs[1].(int)]
	}).(SecretEnvVarOutput)
}

// Configuration for a secret environment variable. It has the information necessary to fetch the secret value from secret manager and expose it as an environment variable.
type SecretEnvVarResponse struct {
	// Name of the environment variable.
	Key string `pulumi:"key"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project string `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret string `pulumi:"secret"`
	// Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
	Version string `pulumi:"version"`
}

// Configuration for a secret environment variable. It has the information necessary to fetch the secret value from secret manager and expose it as an environment variable.
type SecretEnvVarResponseOutput struct{ *pulumi.OutputState }

func (SecretEnvVarResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretEnvVarResponse)(nil)).Elem()
}

func (o SecretEnvVarResponseOutput) ToSecretEnvVarResponseOutput() SecretEnvVarResponseOutput {
	return o
}

func (o SecretEnvVarResponseOutput) ToSecretEnvVarResponseOutputWithContext(ctx context.Context) SecretEnvVarResponseOutput {
	return o
}

// Name of the environment variable.
func (o SecretEnvVarResponseOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v SecretEnvVarResponse) string { return v.Key }).(pulumi.StringOutput)
}

// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
func (o SecretEnvVarResponseOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v SecretEnvVarResponse) string { return v.Project }).(pulumi.StringOutput)
}

// Name of the secret in secret manager (not the full resource name).
func (o SecretEnvVarResponseOutput) Secret() pulumi.StringOutput {
	return o.ApplyT(func(v SecretEnvVarResponse) string { return v.Secret }).(pulumi.StringOutput)
}

// Version of the secret (version number or the string 'latest'). It is recommended to use a numeric version for secret environment variables as any updates to the secret value is not reflected until new instances start.
func (o SecretEnvVarResponseOutput) Version() pulumi.StringOutput {
	return o.ApplyT(func(v SecretEnvVarResponse) string { return v.Version }).(pulumi.StringOutput)
}

type SecretEnvVarResponseArrayOutput struct{ *pulumi.OutputState }

func (SecretEnvVarResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretEnvVarResponse)(nil)).Elem()
}

func (o SecretEnvVarResponseArrayOutput) ToSecretEnvVarResponseArrayOutput() SecretEnvVarResponseArrayOutput {
	return o
}

func (o SecretEnvVarResponseArrayOutput) ToSecretEnvVarResponseArrayOutputWithContext(ctx context.Context) SecretEnvVarResponseArrayOutput {
	return o
}

func (o SecretEnvVarResponseArrayOutput) Index(i pulumi.IntInput) SecretEnvVarResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretEnvVarResponse {
		return vs[0].([]SecretEnvVarResponse)[vs[1].(int)]
	}).(SecretEnvVarResponseOutput)
}

// Configuration for a single version.
type SecretVersion struct {
	// Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mount_path as '/etc/secrets' and path as `secret_foo` would mount the secret value file at `/etc/secrets/secret_foo`.
	Path *string `pulumi:"path"`
	// Version of the secret (version number or the string 'latest'). It is preferable to use `latest` version with secret volumes as secret value changes are reflected immediately.
	Version *string `pulumi:"version"`
}

// SecretVersionInput is an input type that accepts SecretVersionArgs and SecretVersionOutput values.
// You can construct a concrete instance of `SecretVersionInput` via:
//
//	SecretVersionArgs{...}
type SecretVersionInput interface {
	pulumi.Input

	ToSecretVersionOutput() SecretVersionOutput
	ToSecretVersionOutputWithContext(context.Context) SecretVersionOutput
}

// Configuration for a single version.
type SecretVersionArgs struct {
	// Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mount_path as '/etc/secrets' and path as `secret_foo` would mount the secret value file at `/etc/secrets/secret_foo`.
	Path pulumi.StringPtrInput `pulumi:"path"`
	// Version of the secret (version number or the string 'latest'). It is preferable to use `latest` version with secret volumes as secret value changes are reflected immediately.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (SecretVersionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVersion)(nil)).Elem()
}

func (i SecretVersionArgs) ToSecretVersionOutput() SecretVersionOutput {
	return i.ToSecretVersionOutputWithContext(context.Background())
}

func (i SecretVersionArgs) ToSecretVersionOutputWithContext(ctx context.Context) SecretVersionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretVersionOutput)
}

// SecretVersionArrayInput is an input type that accepts SecretVersionArray and SecretVersionArrayOutput values.
// You can construct a concrete instance of `SecretVersionArrayInput` via:
//
//	SecretVersionArray{ SecretVersionArgs{...} }
type SecretVersionArrayInput interface {
	pulumi.Input

	ToSecretVersionArrayOutput() SecretVersionArrayOutput
	ToSecretVersionArrayOutputWithContext(context.Context) SecretVersionArrayOutput
}

type SecretVersionArray []SecretVersionInput

func (SecretVersionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVersion)(nil)).Elem()
}

func (i SecretVersionArray) ToSecretVersionArrayOutput() SecretVersionArrayOutput {
	return i.ToSecretVersionArrayOutputWithContext(context.Background())
}

func (i SecretVersionArray) ToSecretVersionArrayOutputWithContext(ctx context.Context) SecretVersionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretVersionArrayOutput)
}

// Configuration for a single version.
type SecretVersionOutput struct{ *pulumi.OutputState }

func (SecretVersionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVersion)(nil)).Elem()
}

func (o SecretVersionOutput) ToSecretVersionOutput() SecretVersionOutput {
	return o
}

func (o SecretVersionOutput) ToSecretVersionOutputWithContext(ctx context.Context) SecretVersionOutput {
	return o
}

// Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mount_path as '/etc/secrets' and path as `secret_foo` would mount the secret value file at `/etc/secrets/secret_foo`.
func (o SecretVersionOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretVersion) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// Version of the secret (version number or the string 'latest'). It is preferable to use `latest` version with secret volumes as secret value changes are reflected immediately.
func (o SecretVersionOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretVersion) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type SecretVersionArrayOutput struct{ *pulumi.OutputState }

func (SecretVersionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVersion)(nil)).Elem()
}

func (o SecretVersionArrayOutput) ToSecretVersionArrayOutput() SecretVersionArrayOutput {
	return o
}

func (o SecretVersionArrayOutput) ToSecretVersionArrayOutputWithContext(ctx context.Context) SecretVersionArrayOutput {
	return o
}

func (o SecretVersionArrayOutput) Index(i pulumi.IntInput) SecretVersionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretVersion {
		return vs[0].([]SecretVersion)[vs[1].(int)]
	}).(SecretVersionOutput)
}

// Configuration for a single version.
type SecretVersionResponse struct {
	// Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mount_path as '/etc/secrets' and path as `secret_foo` would mount the secret value file at `/etc/secrets/secret_foo`.
	Path string `pulumi:"path"`
	// Version of the secret (version number or the string 'latest'). It is preferable to use `latest` version with secret volumes as secret value changes are reflected immediately.
	Version string `pulumi:"version"`
}

// Configuration for a single version.
type SecretVersionResponseOutput struct{ *pulumi.OutputState }

func (SecretVersionResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVersionResponse)(nil)).Elem()
}

func (o SecretVersionResponseOutput) ToSecretVersionResponseOutput() SecretVersionResponseOutput {
	return o
}

func (o SecretVersionResponseOutput) ToSecretVersionResponseOutputWithContext(ctx context.Context) SecretVersionResponseOutput {
	return o
}

// Relative path of the file under the mount path where the secret value for this version will be fetched and made available. For example, setting the mount_path as '/etc/secrets' and path as `secret_foo` would mount the secret value file at `/etc/secrets/secret_foo`.
func (o SecretVersionResponseOutput) Path() pulumi.StringOutput {
	return o.ApplyT(func(v SecretVersionResponse) string { return v.Path }).(pulumi.StringOutput)
}

// Version of the secret (version number or the string 'latest'). It is preferable to use `latest` version with secret volumes as secret value changes are reflected immediately.
func (o SecretVersionResponseOutput) Version() pulumi.StringOutput {
	return o.ApplyT(func(v SecretVersionResponse) string { return v.Version }).(pulumi.StringOutput)
}

type SecretVersionResponseArrayOutput struct{ *pulumi.OutputState }

func (SecretVersionResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVersionResponse)(nil)).Elem()
}

func (o SecretVersionResponseArrayOutput) ToSecretVersionResponseArrayOutput() SecretVersionResponseArrayOutput {
	return o
}

func (o SecretVersionResponseArrayOutput) ToSecretVersionResponseArrayOutputWithContext(ctx context.Context) SecretVersionResponseArrayOutput {
	return o
}

func (o SecretVersionResponseArrayOutput) Index(i pulumi.IntInput) SecretVersionResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretVersionResponse {
		return vs[0].([]SecretVersionResponse)[vs[1].(int)]
	}).(SecretVersionResponseOutput)
}

// Configuration for a secret volume. It has the information necessary to fetch the secret value from secret manager and make it available as files mounted at the requested paths within the application container.
type SecretVolume struct {
	// The path within the container to mount the secret volume. For example, setting the mount_path as `/etc/secrets` would mount the secret value files under the `/etc/secrets` directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
	MountPath *string `pulumi:"mountPath"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project *string `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret *string `pulumi:"secret"`
	// List of secret versions to mount for this secret. If empty, the `latest` version of the secret will be made available in a file named after the secret under the mount point.
	Versions []SecretVersion `pulumi:"versions"`
}

// SecretVolumeInput is an input type that accepts SecretVolumeArgs and SecretVolumeOutput values.
// You can construct a concrete instance of `SecretVolumeInput` via:
//
//	SecretVolumeArgs{...}
type SecretVolumeInput interface {
	pulumi.Input

	ToSecretVolumeOutput() SecretVolumeOutput
	ToSecretVolumeOutputWithContext(context.Context) SecretVolumeOutput
}

// Configuration for a secret volume. It has the information necessary to fetch the secret value from secret manager and make it available as files mounted at the requested paths within the application container.
type SecretVolumeArgs struct {
	// The path within the container to mount the secret volume. For example, setting the mount_path as `/etc/secrets` would mount the secret value files under the `/etc/secrets` directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
	MountPath pulumi.StringPtrInput `pulumi:"mountPath"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project pulumi.StringPtrInput `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret pulumi.StringPtrInput `pulumi:"secret"`
	// List of secret versions to mount for this secret. If empty, the `latest` version of the secret will be made available in a file named after the secret under the mount point.
	Versions SecretVersionArrayInput `pulumi:"versions"`
}

func (SecretVolumeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVolume)(nil)).Elem()
}

func (i SecretVolumeArgs) ToSecretVolumeOutput() SecretVolumeOutput {
	return i.ToSecretVolumeOutputWithContext(context.Background())
}

func (i SecretVolumeArgs) ToSecretVolumeOutputWithContext(ctx context.Context) SecretVolumeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeOutput)
}

// SecretVolumeArrayInput is an input type that accepts SecretVolumeArray and SecretVolumeArrayOutput values.
// You can construct a concrete instance of `SecretVolumeArrayInput` via:
//
//	SecretVolumeArray{ SecretVolumeArgs{...} }
type SecretVolumeArrayInput interface {
	pulumi.Input

	ToSecretVolumeArrayOutput() SecretVolumeArrayOutput
	ToSecretVolumeArrayOutputWithContext(context.Context) SecretVolumeArrayOutput
}

type SecretVolumeArray []SecretVolumeInput

func (SecretVolumeArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVolume)(nil)).Elem()
}

func (i SecretVolumeArray) ToSecretVolumeArrayOutput() SecretVolumeArrayOutput {
	return i.ToSecretVolumeArrayOutputWithContext(context.Background())
}

func (i SecretVolumeArray) ToSecretVolumeArrayOutputWithContext(ctx context.Context) SecretVolumeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SecretVolumeArrayOutput)
}

// Configuration for a secret volume. It has the information necessary to fetch the secret value from secret manager and make it available as files mounted at the requested paths within the application container.
type SecretVolumeOutput struct{ *pulumi.OutputState }

func (SecretVolumeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVolume)(nil)).Elem()
}

func (o SecretVolumeOutput) ToSecretVolumeOutput() SecretVolumeOutput {
	return o
}

func (o SecretVolumeOutput) ToSecretVolumeOutputWithContext(ctx context.Context) SecretVolumeOutput {
	return o
}

// The path within the container to mount the secret volume. For example, setting the mount_path as `/etc/secrets` would mount the secret value files under the `/etc/secrets` directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
func (o SecretVolumeOutput) MountPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretVolume) *string { return v.MountPath }).(pulumi.StringPtrOutput)
}

// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
func (o SecretVolumeOutput) Project() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretVolume) *string { return v.Project }).(pulumi.StringPtrOutput)
}

// Name of the secret in secret manager (not the full resource name).
func (o SecretVolumeOutput) Secret() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SecretVolume) *string { return v.Secret }).(pulumi.StringPtrOutput)
}

// List of secret versions to mount for this secret. If empty, the `latest` version of the secret will be made available in a file named after the secret under the mount point.
func (o SecretVolumeOutput) Versions() SecretVersionArrayOutput {
	return o.ApplyT(func(v SecretVolume) []SecretVersion { return v.Versions }).(SecretVersionArrayOutput)
}

type SecretVolumeArrayOutput struct{ *pulumi.OutputState }

func (SecretVolumeArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVolume)(nil)).Elem()
}

func (o SecretVolumeArrayOutput) ToSecretVolumeArrayOutput() SecretVolumeArrayOutput {
	return o
}

func (o SecretVolumeArrayOutput) ToSecretVolumeArrayOutputWithContext(ctx context.Context) SecretVolumeArrayOutput {
	return o
}

func (o SecretVolumeArrayOutput) Index(i pulumi.IntInput) SecretVolumeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretVolume {
		return vs[0].([]SecretVolume)[vs[1].(int)]
	}).(SecretVolumeOutput)
}

// Configuration for a secret volume. It has the information necessary to fetch the secret value from secret manager and make it available as files mounted at the requested paths within the application container.
type SecretVolumeResponse struct {
	// The path within the container to mount the secret volume. For example, setting the mount_path as `/etc/secrets` would mount the secret value files under the `/etc/secrets` directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
	MountPath string `pulumi:"mountPath"`
	// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
	Project string `pulumi:"project"`
	// Name of the secret in secret manager (not the full resource name).
	Secret string `pulumi:"secret"`
	// List of secret versions to mount for this secret. If empty, the `latest` version of the secret will be made available in a file named after the secret under the mount point.
	Versions []SecretVersionResponse `pulumi:"versions"`
}

// Configuration for a secret volume. It has the information necessary to fetch the secret value from secret manager and make it available as files mounted at the requested paths within the application container.
type SecretVolumeResponseOutput struct{ *pulumi.OutputState }

func (SecretVolumeResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SecretVolumeResponse)(nil)).Elem()
}

func (o SecretVolumeResponseOutput) ToSecretVolumeResponseOutput() SecretVolumeResponseOutput {
	return o
}

func (o SecretVolumeResponseOutput) ToSecretVolumeResponseOutputWithContext(ctx context.Context) SecretVolumeResponseOutput {
	return o
}

// The path within the container to mount the secret volume. For example, setting the mount_path as `/etc/secrets` would mount the secret value files under the `/etc/secrets` directory. This directory will also be completely shadowed and unavailable to mount any other secrets. Recommended mount path: /etc/secrets
func (o SecretVolumeResponseOutput) MountPath() pulumi.StringOutput {
	return o.ApplyT(func(v SecretVolumeResponse) string { return v.MountPath }).(pulumi.StringOutput)
}

// Project identifier (preferably project number but can also be the project ID) of the project that contains the secret. If not set, it is assumed that the secret is in the same project as the function.
func (o SecretVolumeResponseOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v SecretVolumeResponse) string { return v.Project }).(pulumi.StringOutput)
}

// Name of the secret in secret manager (not the full resource name).
func (o SecretVolumeResponseOutput) Secret() pulumi.StringOutput {
	return o.ApplyT(func(v SecretVolumeResponse) string { return v.Secret }).(pulumi.StringOutput)
}

// List of secret versions to mount for this secret. If empty, the `latest` version of the secret will be made available in a file named after the secret under the mount point.
func (o SecretVolumeResponseOutput) Versions() SecretVersionResponseArrayOutput {
	return o.ApplyT(func(v SecretVolumeResponse) []SecretVersionResponse { return v.Versions }).(SecretVersionResponseArrayOutput)
}

type SecretVolumeResponseArrayOutput struct{ *pulumi.OutputState }

func (SecretVolumeResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]SecretVolumeResponse)(nil)).Elem()
}

func (o SecretVolumeResponseArrayOutput) ToSecretVolumeResponseArrayOutput() SecretVolumeResponseArrayOutput {
	return o
}

func (o SecretVolumeResponseArrayOutput) ToSecretVolumeResponseArrayOutputWithContext(ctx context.Context) SecretVolumeResponseArrayOutput {
	return o
}

func (o SecretVolumeResponseArrayOutput) Index(i pulumi.IntInput) SecretVolumeResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SecretVolumeResponse {
		return vs[0].([]SecretVolumeResponse)[vs[1].(int)]
	}).(SecretVolumeResponseOutput)
}

// Describes the Service being deployed. Currently Supported : Cloud Run (fully managed).
type ServiceConfig struct {
	// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
	AllTrafficOnLatestRevision *bool `pulumi:"allTrafficOnLatestRevision"`
	// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
	AvailableCpu *string `pulumi:"availableCpu"`
	// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
	AvailableMemory *string `pulumi:"availableMemory"`
	// Environment variables that shall be available during function execution.
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// The ingress settings for the function, controlling what traffic can reach it.
	IngressSettings *ServiceConfigIngressSettings `pulumi:"ingressSettings"`
	// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
	MaxInstanceCount *int `pulumi:"maxInstanceCount"`
	// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
	MaxInstanceRequestConcurrency *int `pulumi:"maxInstanceRequestConcurrency"`
	// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
	MinInstanceCount *int `pulumi:"minInstanceCount"`
	// Secret environment variables configuration.
	SecretEnvironmentVariables []SecretEnvVar `pulumi:"secretEnvironmentVariables"`
	// Secret volumes configuration.
	SecretVolumes []SecretVolume `pulumi:"secretVolumes"`
	// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
	SecurityLevel *ServiceConfigSecurityLevel `pulumi:"securityLevel"`
	// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail *string `pulumi:"serviceAccountEmail"`
	// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
	TimeoutSeconds *int `pulumi:"timeoutSeconds"`
	// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
	VpcConnector *string `pulumi:"vpcConnector"`
	// The egress settings for the connector, controlling what traffic is diverted through it.
	VpcConnectorEgressSettings *ServiceConfigVpcConnectorEgressSettings `pulumi:"vpcConnectorEgressSettings"`
}

// ServiceConfigInput is an input type that accepts ServiceConfigArgs and ServiceConfigOutput values.
// You can construct a concrete instance of `ServiceConfigInput` via:
//
//	ServiceConfigArgs{...}
type ServiceConfigInput interface {
	pulumi.Input

	ToServiceConfigOutput() ServiceConfigOutput
	ToServiceConfigOutputWithContext(context.Context) ServiceConfigOutput
}

// Describes the Service being deployed. Currently Supported : Cloud Run (fully managed).
type ServiceConfigArgs struct {
	// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
	AllTrafficOnLatestRevision pulumi.BoolPtrInput `pulumi:"allTrafficOnLatestRevision"`
	// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
	AvailableCpu pulumi.StringPtrInput `pulumi:"availableCpu"`
	// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
	AvailableMemory pulumi.StringPtrInput `pulumi:"availableMemory"`
	// Environment variables that shall be available during function execution.
	EnvironmentVariables pulumi.StringMapInput `pulumi:"environmentVariables"`
	// The ingress settings for the function, controlling what traffic can reach it.
	IngressSettings ServiceConfigIngressSettingsPtrInput `pulumi:"ingressSettings"`
	// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
	MaxInstanceCount pulumi.IntPtrInput `pulumi:"maxInstanceCount"`
	// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
	MaxInstanceRequestConcurrency pulumi.IntPtrInput `pulumi:"maxInstanceRequestConcurrency"`
	// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
	MinInstanceCount pulumi.IntPtrInput `pulumi:"minInstanceCount"`
	// Secret environment variables configuration.
	SecretEnvironmentVariables SecretEnvVarArrayInput `pulumi:"secretEnvironmentVariables"`
	// Secret volumes configuration.
	SecretVolumes SecretVolumeArrayInput `pulumi:"secretVolumes"`
	// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
	SecurityLevel ServiceConfigSecurityLevelPtrInput `pulumi:"securityLevel"`
	// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail pulumi.StringPtrInput `pulumi:"serviceAccountEmail"`
	// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
	TimeoutSeconds pulumi.IntPtrInput `pulumi:"timeoutSeconds"`
	// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
	VpcConnector pulumi.StringPtrInput `pulumi:"vpcConnector"`
	// The egress settings for the connector, controlling what traffic is diverted through it.
	VpcConnectorEgressSettings ServiceConfigVpcConnectorEgressSettingsPtrInput `pulumi:"vpcConnectorEgressSettings"`
}

func (ServiceConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceConfig)(nil)).Elem()
}

func (i ServiceConfigArgs) ToServiceConfigOutput() ServiceConfigOutput {
	return i.ToServiceConfigOutputWithContext(context.Background())
}

func (i ServiceConfigArgs) ToServiceConfigOutputWithContext(ctx context.Context) ServiceConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceConfigOutput)
}

func (i ServiceConfigArgs) ToServiceConfigPtrOutput() ServiceConfigPtrOutput {
	return i.ToServiceConfigPtrOutputWithContext(context.Background())
}

func (i ServiceConfigArgs) ToServiceConfigPtrOutputWithContext(ctx context.Context) ServiceConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceConfigOutput).ToServiceConfigPtrOutputWithContext(ctx)
}

// ServiceConfigPtrInput is an input type that accepts ServiceConfigArgs, ServiceConfigPtr and ServiceConfigPtrOutput values.
// You can construct a concrete instance of `ServiceConfigPtrInput` via:
//
//	        ServiceConfigArgs{...}
//
//	or:
//
//	        nil
type ServiceConfigPtrInput interface {
	pulumi.Input

	ToServiceConfigPtrOutput() ServiceConfigPtrOutput
	ToServiceConfigPtrOutputWithContext(context.Context) ServiceConfigPtrOutput
}

type serviceConfigPtrType ServiceConfigArgs

func ServiceConfigPtr(v *ServiceConfigArgs) ServiceConfigPtrInput {
	return (*serviceConfigPtrType)(v)
}

func (*serviceConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceConfig)(nil)).Elem()
}

func (i *serviceConfigPtrType) ToServiceConfigPtrOutput() ServiceConfigPtrOutput {
	return i.ToServiceConfigPtrOutputWithContext(context.Background())
}

func (i *serviceConfigPtrType) ToServiceConfigPtrOutputWithContext(ctx context.Context) ServiceConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceConfigPtrOutput)
}

// Describes the Service being deployed. Currently Supported : Cloud Run (fully managed).
type ServiceConfigOutput struct{ *pulumi.OutputState }

func (ServiceConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceConfig)(nil)).Elem()
}

func (o ServiceConfigOutput) ToServiceConfigOutput() ServiceConfigOutput {
	return o
}

func (o ServiceConfigOutput) ToServiceConfigOutputWithContext(ctx context.Context) ServiceConfigOutput {
	return o
}

func (o ServiceConfigOutput) ToServiceConfigPtrOutput() ServiceConfigPtrOutput {
	return o.ToServiceConfigPtrOutputWithContext(context.Background())
}

func (o ServiceConfigOutput) ToServiceConfigPtrOutputWithContext(ctx context.Context) ServiceConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceConfig) *ServiceConfig {
		return &v
	}).(ServiceConfigPtrOutput)
}

// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
func (o ServiceConfigOutput) AllTrafficOnLatestRevision() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *bool { return v.AllTrafficOnLatestRevision }).(pulumi.BoolPtrOutput)
}

// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
func (o ServiceConfigOutput) AvailableCpu() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *string { return v.AvailableCpu }).(pulumi.StringPtrOutput)
}

// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
func (o ServiceConfigOutput) AvailableMemory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *string { return v.AvailableMemory }).(pulumi.StringPtrOutput)
}

// Environment variables that shall be available during function execution.
func (o ServiceConfigOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v ServiceConfig) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// The ingress settings for the function, controlling what traffic can reach it.
func (o ServiceConfigOutput) IngressSettings() ServiceConfigIngressSettingsPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *ServiceConfigIngressSettings { return v.IngressSettings }).(ServiceConfigIngressSettingsPtrOutput)
}

// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
func (o ServiceConfigOutput) MaxInstanceCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *int { return v.MaxInstanceCount }).(pulumi.IntPtrOutput)
}

// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
func (o ServiceConfigOutput) MaxInstanceRequestConcurrency() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *int { return v.MaxInstanceRequestConcurrency }).(pulumi.IntPtrOutput)
}

// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
func (o ServiceConfigOutput) MinInstanceCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *int { return v.MinInstanceCount }).(pulumi.IntPtrOutput)
}

// Secret environment variables configuration.
func (o ServiceConfigOutput) SecretEnvironmentVariables() SecretEnvVarArrayOutput {
	return o.ApplyT(func(v ServiceConfig) []SecretEnvVar { return v.SecretEnvironmentVariables }).(SecretEnvVarArrayOutput)
}

// Secret volumes configuration.
func (o ServiceConfigOutput) SecretVolumes() SecretVolumeArrayOutput {
	return o.ApplyT(func(v ServiceConfig) []SecretVolume { return v.SecretVolumes }).(SecretVolumeArrayOutput)
}

// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
func (o ServiceConfigOutput) SecurityLevel() ServiceConfigSecurityLevelPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *ServiceConfigSecurityLevel { return v.SecurityLevel }).(ServiceConfigSecurityLevelPtrOutput)
}

// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
func (o ServiceConfigOutput) ServiceAccountEmail() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *string { return v.ServiceAccountEmail }).(pulumi.StringPtrOutput)
}

// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
func (o ServiceConfigOutput) TimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *int { return v.TimeoutSeconds }).(pulumi.IntPtrOutput)
}

// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
func (o ServiceConfigOutput) VpcConnector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *string { return v.VpcConnector }).(pulumi.StringPtrOutput)
}

// The egress settings for the connector, controlling what traffic is diverted through it.
func (o ServiceConfigOutput) VpcConnectorEgressSettings() ServiceConfigVpcConnectorEgressSettingsPtrOutput {
	return o.ApplyT(func(v ServiceConfig) *ServiceConfigVpcConnectorEgressSettings { return v.VpcConnectorEgressSettings }).(ServiceConfigVpcConnectorEgressSettingsPtrOutput)
}

type ServiceConfigPtrOutput struct{ *pulumi.OutputState }

func (ServiceConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceConfig)(nil)).Elem()
}

func (o ServiceConfigPtrOutput) ToServiceConfigPtrOutput() ServiceConfigPtrOutput {
	return o
}

func (o ServiceConfigPtrOutput) ToServiceConfigPtrOutputWithContext(ctx context.Context) ServiceConfigPtrOutput {
	return o
}

func (o ServiceConfigPtrOutput) Elem() ServiceConfigOutput {
	return o.ApplyT(func(v *ServiceConfig) ServiceConfig {
		if v != nil {
			return *v
		}
		var ret ServiceConfig
		return ret
	}).(ServiceConfigOutput)
}

// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
func (o ServiceConfigPtrOutput) AllTrafficOnLatestRevision() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *bool {
		if v == nil {
			return nil
		}
		return v.AllTrafficOnLatestRevision
	}).(pulumi.BoolPtrOutput)
}

// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
func (o ServiceConfigPtrOutput) AvailableCpu() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *string {
		if v == nil {
			return nil
		}
		return v.AvailableCpu
	}).(pulumi.StringPtrOutput)
}

// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
func (o ServiceConfigPtrOutput) AvailableMemory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *string {
		if v == nil {
			return nil
		}
		return v.AvailableMemory
	}).(pulumi.StringPtrOutput)
}

// Environment variables that shall be available during function execution.
func (o ServiceConfigPtrOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v *ServiceConfig) map[string]string {
		if v == nil {
			return nil
		}
		return v.EnvironmentVariables
	}).(pulumi.StringMapOutput)
}

// The ingress settings for the function, controlling what traffic can reach it.
func (o ServiceConfigPtrOutput) IngressSettings() ServiceConfigIngressSettingsPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *ServiceConfigIngressSettings {
		if v == nil {
			return nil
		}
		return v.IngressSettings
	}).(ServiceConfigIngressSettingsPtrOutput)
}

// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
func (o ServiceConfigPtrOutput) MaxInstanceCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *int {
		if v == nil {
			return nil
		}
		return v.MaxInstanceCount
	}).(pulumi.IntPtrOutput)
}

// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
func (o ServiceConfigPtrOutput) MaxInstanceRequestConcurrency() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *int {
		if v == nil {
			return nil
		}
		return v.MaxInstanceRequestConcurrency
	}).(pulumi.IntPtrOutput)
}

// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
func (o ServiceConfigPtrOutput) MinInstanceCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *int {
		if v == nil {
			return nil
		}
		return v.MinInstanceCount
	}).(pulumi.IntPtrOutput)
}

// Secret environment variables configuration.
func (o ServiceConfigPtrOutput) SecretEnvironmentVariables() SecretEnvVarArrayOutput {
	return o.ApplyT(func(v *ServiceConfig) []SecretEnvVar {
		if v == nil {
			return nil
		}
		return v.SecretEnvironmentVariables
	}).(SecretEnvVarArrayOutput)
}

// Secret volumes configuration.
func (o ServiceConfigPtrOutput) SecretVolumes() SecretVolumeArrayOutput {
	return o.ApplyT(func(v *ServiceConfig) []SecretVolume {
		if v == nil {
			return nil
		}
		return v.SecretVolumes
	}).(SecretVolumeArrayOutput)
}

// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
func (o ServiceConfigPtrOutput) SecurityLevel() ServiceConfigSecurityLevelPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *ServiceConfigSecurityLevel {
		if v == nil {
			return nil
		}
		return v.SecurityLevel
	}).(ServiceConfigSecurityLevelPtrOutput)
}

// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
func (o ServiceConfigPtrOutput) ServiceAccountEmail() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *string {
		if v == nil {
			return nil
		}
		return v.ServiceAccountEmail
	}).(pulumi.StringPtrOutput)
}

// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
func (o ServiceConfigPtrOutput) TimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *int {
		if v == nil {
			return nil
		}
		return v.TimeoutSeconds
	}).(pulumi.IntPtrOutput)
}

// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
func (o ServiceConfigPtrOutput) VpcConnector() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *string {
		if v == nil {
			return nil
		}
		return v.VpcConnector
	}).(pulumi.StringPtrOutput)
}

// The egress settings for the connector, controlling what traffic is diverted through it.
func (o ServiceConfigPtrOutput) VpcConnectorEgressSettings() ServiceConfigVpcConnectorEgressSettingsPtrOutput {
	return o.ApplyT(func(v *ServiceConfig) *ServiceConfigVpcConnectorEgressSettings {
		if v == nil {
			return nil
		}
		return v.VpcConnectorEgressSettings
	}).(ServiceConfigVpcConnectorEgressSettingsPtrOutput)
}

// Describes the Service being deployed. Currently Supported : Cloud Run (fully managed).
type ServiceConfigResponse struct {
	// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
	AllTrafficOnLatestRevision bool `pulumi:"allTrafficOnLatestRevision"`
	// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
	AvailableCpu string `pulumi:"availableCpu"`
	// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
	AvailableMemory string `pulumi:"availableMemory"`
	// Environment variables that shall be available during function execution.
	EnvironmentVariables map[string]string `pulumi:"environmentVariables"`
	// The ingress settings for the function, controlling what traffic can reach it.
	IngressSettings string `pulumi:"ingressSettings"`
	// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
	MaxInstanceCount int `pulumi:"maxInstanceCount"`
	// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
	MaxInstanceRequestConcurrency int `pulumi:"maxInstanceRequestConcurrency"`
	// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
	MinInstanceCount int `pulumi:"minInstanceCount"`
	// The name of service revision.
	Revision string `pulumi:"revision"`
	// Secret environment variables configuration.
	SecretEnvironmentVariables []SecretEnvVarResponse `pulumi:"secretEnvironmentVariables"`
	// Secret volumes configuration.
	SecretVolumes []SecretVolumeResponse `pulumi:"secretVolumes"`
	// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
	SecurityLevel string `pulumi:"securityLevel"`
	// Name of the service associated with a Function. The format of this field is `projects/{project}/locations/{region}/services/{service}`
	Service string `pulumi:"service"`
	// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
	ServiceAccountEmail string `pulumi:"serviceAccountEmail"`
	// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
	TimeoutSeconds int `pulumi:"timeoutSeconds"`
	// URI of the Service deployed.
	Uri string `pulumi:"uri"`
	// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
	VpcConnector string `pulumi:"vpcConnector"`
	// The egress settings for the connector, controlling what traffic is diverted through it.
	VpcConnectorEgressSettings string `pulumi:"vpcConnectorEgressSettings"`
}

// Describes the Service being deployed. Currently Supported : Cloud Run (fully managed).
type ServiceConfigResponseOutput struct{ *pulumi.OutputState }

func (ServiceConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceConfigResponse)(nil)).Elem()
}

func (o ServiceConfigResponseOutput) ToServiceConfigResponseOutput() ServiceConfigResponseOutput {
	return o
}

func (o ServiceConfigResponseOutput) ToServiceConfigResponseOutputWithContext(ctx context.Context) ServiceConfigResponseOutput {
	return o
}

// Whether 100% of traffic is routed to the latest revision. On CreateFunction and UpdateFunction, when set to true, the revision being deployed will serve 100% of traffic, ignoring any traffic split settings, if any. On GetFunction, true will be returned if the latest revision is serving 100% of traffic.
func (o ServiceConfigResponseOutput) AllTrafficOnLatestRevision() pulumi.BoolOutput {
	return o.ApplyT(func(v ServiceConfigResponse) bool { return v.AllTrafficOnLatestRevision }).(pulumi.BoolOutput)
}

// [Preview] The number of CPUs used in a single container instance. Default value is calculated from available memory. Supports the same values as Cloud Run, see https://cloud.google.com/run/docs/reference/rest/v1/Container#resourcerequirements Example: "1" indicates 1 vCPU
func (o ServiceConfigResponseOutput) AvailableCpu() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.AvailableCpu }).(pulumi.StringOutput)
}

// The amount of memory available for a function. Defaults to 256M. Supported units are k, M, G, Mi, Gi. If no unit is supplied the value is interpreted as bytes. See https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go a full description.
func (o ServiceConfigResponseOutput) AvailableMemory() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.AvailableMemory }).(pulumi.StringOutput)
}

// Environment variables that shall be available during function execution.
func (o ServiceConfigResponseOutput) EnvironmentVariables() pulumi.StringMapOutput {
	return o.ApplyT(func(v ServiceConfigResponse) map[string]string { return v.EnvironmentVariables }).(pulumi.StringMapOutput)
}

// The ingress settings for the function, controlling what traffic can reach it.
func (o ServiceConfigResponseOutput) IngressSettings() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.IngressSettings }).(pulumi.StringOutput)
}

// The limit on the maximum number of function instances that may coexist at a given time. In some cases, such as rapid traffic surges, Cloud Functions may, for a short period of time, create more instances than the specified max instances limit. If your function cannot tolerate this temporary behavior, you may want to factor in a safety margin and set a lower max instances value than your function can tolerate. See the [Max Instances](https://cloud.google.com/functions/docs/max-instances) Guide for more details.
func (o ServiceConfigResponseOutput) MaxInstanceCount() pulumi.IntOutput {
	return o.ApplyT(func(v ServiceConfigResponse) int { return v.MaxInstanceCount }).(pulumi.IntOutput)
}

// [Preview] Sets the maximum number of concurrent requests that each instance can receive. Defaults to 1.
func (o ServiceConfigResponseOutput) MaxInstanceRequestConcurrency() pulumi.IntOutput {
	return o.ApplyT(func(v ServiceConfigResponse) int { return v.MaxInstanceRequestConcurrency }).(pulumi.IntOutput)
}

// The limit on the minimum number of function instances that may coexist at a given time. Function instances are kept in idle state for a short period after they finished executing the request to reduce cold start time for subsequent requests. Setting a minimum instance count will ensure that the given number of instances are kept running in idle state always. This can help with cold start times when jump in incoming request count occurs after the idle instance would have been stopped in the default case.
func (o ServiceConfigResponseOutput) MinInstanceCount() pulumi.IntOutput {
	return o.ApplyT(func(v ServiceConfigResponse) int { return v.MinInstanceCount }).(pulumi.IntOutput)
}

// The name of service revision.
func (o ServiceConfigResponseOutput) Revision() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.Revision }).(pulumi.StringOutput)
}

// Secret environment variables configuration.
func (o ServiceConfigResponseOutput) SecretEnvironmentVariables() SecretEnvVarResponseArrayOutput {
	return o.ApplyT(func(v ServiceConfigResponse) []SecretEnvVarResponse { return v.SecretEnvironmentVariables }).(SecretEnvVarResponseArrayOutput)
}

// Secret volumes configuration.
func (o ServiceConfigResponseOutput) SecretVolumes() SecretVolumeResponseArrayOutput {
	return o.ApplyT(func(v ServiceConfigResponse) []SecretVolumeResponse { return v.SecretVolumes }).(SecretVolumeResponseArrayOutput)
}

// Security level configure whether the function only accepts https. This configuration is only applicable to 1st Gen functions with Http trigger. By default https is optional for 1st Gen functions; 2nd Gen functions are https ONLY.
func (o ServiceConfigResponseOutput) SecurityLevel() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.SecurityLevel }).(pulumi.StringOutput)
}

// Name of the service associated with a Function. The format of this field is `projects/{project}/locations/{region}/services/{service}`
func (o ServiceConfigResponseOutput) Service() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.Service }).(pulumi.StringOutput)
}

// The email of the service's service account. If empty, defaults to `{project_number}-compute@developer.gserviceaccount.com`.
func (o ServiceConfigResponseOutput) ServiceAccountEmail() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.ServiceAccountEmail }).(pulumi.StringOutput)
}

// The function execution timeout. Execution is considered failed and can be terminated if the function is not completed at the end of the timeout period. Defaults to 60 seconds.
func (o ServiceConfigResponseOutput) TimeoutSeconds() pulumi.IntOutput {
	return o.ApplyT(func(v ServiceConfigResponse) int { return v.TimeoutSeconds }).(pulumi.IntOutput)
}

// URI of the Service deployed.
func (o ServiceConfigResponseOutput) Uri() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.Uri }).(pulumi.StringOutput)
}

// The Serverless VPC Access connector that this cloud function can connect to. The format of this field is `projects/*/locations/*/connectors/*`.
func (o ServiceConfigResponseOutput) VpcConnector() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.VpcConnector }).(pulumi.StringOutput)
}

// The egress settings for the connector, controlling what traffic is diverted through it.
func (o ServiceConfigResponseOutput) VpcConnectorEgressSettings() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceConfigResponse) string { return v.VpcConnectorEgressSettings }).(pulumi.StringOutput)
}

// The location of the function source code.
type Source struct {
	// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
	GitUri *string `pulumi:"gitUri"`
	// If provided, get the source from this location in a Cloud Source Repository.
	RepoSource *RepoSource `pulumi:"repoSource"`
	// If provided, get the source from this location in Google Cloud Storage.
	StorageSource *StorageSource `pulumi:"storageSource"`
}

// SourceInput is an input type that accepts SourceArgs and SourceOutput values.
// You can construct a concrete instance of `SourceInput` via:
//
//	SourceArgs{...}
type SourceInput interface {
	pulumi.Input

	ToSourceOutput() SourceOutput
	ToSourceOutputWithContext(context.Context) SourceOutput
}

// The location of the function source code.
type SourceArgs struct {
	// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
	GitUri pulumi.StringPtrInput `pulumi:"gitUri"`
	// If provided, get the source from this location in a Cloud Source Repository.
	RepoSource RepoSourcePtrInput `pulumi:"repoSource"`
	// If provided, get the source from this location in Google Cloud Storage.
	StorageSource StorageSourcePtrInput `pulumi:"storageSource"`
}

func (SourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Source)(nil)).Elem()
}

func (i SourceArgs) ToSourceOutput() SourceOutput {
	return i.ToSourceOutputWithContext(context.Background())
}

func (i SourceArgs) ToSourceOutputWithContext(ctx context.Context) SourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SourceOutput)
}

func (i SourceArgs) ToSourcePtrOutput() SourcePtrOutput {
	return i.ToSourcePtrOutputWithContext(context.Background())
}

func (i SourceArgs) ToSourcePtrOutputWithContext(ctx context.Context) SourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SourceOutput).ToSourcePtrOutputWithContext(ctx)
}

// SourcePtrInput is an input type that accepts SourceArgs, SourcePtr and SourcePtrOutput values.
// You can construct a concrete instance of `SourcePtrInput` via:
//
//	        SourceArgs{...}
//
//	or:
//
//	        nil
type SourcePtrInput interface {
	pulumi.Input

	ToSourcePtrOutput() SourcePtrOutput
	ToSourcePtrOutputWithContext(context.Context) SourcePtrOutput
}

type sourcePtrType SourceArgs

func SourcePtr(v *SourceArgs) SourcePtrInput {
	return (*sourcePtrType)(v)
}

func (*sourcePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Source)(nil)).Elem()
}

func (i *sourcePtrType) ToSourcePtrOutput() SourcePtrOutput {
	return i.ToSourcePtrOutputWithContext(context.Background())
}

func (i *sourcePtrType) ToSourcePtrOutputWithContext(ctx context.Context) SourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SourcePtrOutput)
}

// The location of the function source code.
type SourceOutput struct{ *pulumi.OutputState }

func (SourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Source)(nil)).Elem()
}

func (o SourceOutput) ToSourceOutput() SourceOutput {
	return o
}

func (o SourceOutput) ToSourceOutputWithContext(ctx context.Context) SourceOutput {
	return o
}

func (o SourceOutput) ToSourcePtrOutput() SourcePtrOutput {
	return o.ToSourcePtrOutputWithContext(context.Background())
}

func (o SourceOutput) ToSourcePtrOutputWithContext(ctx context.Context) SourcePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Source) *Source {
		return &v
	}).(SourcePtrOutput)
}

// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
func (o SourceOutput) GitUri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Source) *string { return v.GitUri }).(pulumi.StringPtrOutput)
}

// If provided, get the source from this location in a Cloud Source Repository.
func (o SourceOutput) RepoSource() RepoSourcePtrOutput {
	return o.ApplyT(func(v Source) *RepoSource { return v.RepoSource }).(RepoSourcePtrOutput)
}

// If provided, get the source from this location in Google Cloud Storage.
func (o SourceOutput) StorageSource() StorageSourcePtrOutput {
	return o.ApplyT(func(v Source) *StorageSource { return v.StorageSource }).(StorageSourcePtrOutput)
}

type SourcePtrOutput struct{ *pulumi.OutputState }

func (SourcePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Source)(nil)).Elem()
}

func (o SourcePtrOutput) ToSourcePtrOutput() SourcePtrOutput {
	return o
}

func (o SourcePtrOutput) ToSourcePtrOutputWithContext(ctx context.Context) SourcePtrOutput {
	return o
}

func (o SourcePtrOutput) Elem() SourceOutput {
	return o.ApplyT(func(v *Source) Source {
		if v != nil {
			return *v
		}
		var ret Source
		return ret
	}).(SourceOutput)
}

// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
func (o SourcePtrOutput) GitUri() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Source) *string {
		if v == nil {
			return nil
		}
		return v.GitUri
	}).(pulumi.StringPtrOutput)
}

// If provided, get the source from this location in a Cloud Source Repository.
func (o SourcePtrOutput) RepoSource() RepoSourcePtrOutput {
	return o.ApplyT(func(v *Source) *RepoSource {
		if v == nil {
			return nil
		}
		return v.RepoSource
	}).(RepoSourcePtrOutput)
}

// If provided, get the source from this location in Google Cloud Storage.
func (o SourcePtrOutput) StorageSource() StorageSourcePtrOutput {
	return o.ApplyT(func(v *Source) *StorageSource {
		if v == nil {
			return nil
		}
		return v.StorageSource
	}).(StorageSourcePtrOutput)
}

// Provenance of the source. Ways to find the original source, or verify that some source was used for this build.
type SourceProvenanceResponse struct {
	// A copy of the build's `source.git_uri`, if exists, with any commits resolved.
	GitUri string `pulumi:"gitUri"`
	// A copy of the build's `source.repo_source`, if exists, with any revisions resolved.
	ResolvedRepoSource RepoSourceResponse `pulumi:"resolvedRepoSource"`
	// A copy of the build's `source.storage_source`, if exists, with any generations resolved.
	ResolvedStorageSource StorageSourceResponse `pulumi:"resolvedStorageSource"`
}

// Provenance of the source. Ways to find the original source, or verify that some source was used for this build.
type SourceProvenanceResponseOutput struct{ *pulumi.OutputState }

func (SourceProvenanceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SourceProvenanceResponse)(nil)).Elem()
}

func (o SourceProvenanceResponseOutput) ToSourceProvenanceResponseOutput() SourceProvenanceResponseOutput {
	return o
}

func (o SourceProvenanceResponseOutput) ToSourceProvenanceResponseOutputWithContext(ctx context.Context) SourceProvenanceResponseOutput {
	return o
}

// A copy of the build's `source.git_uri`, if exists, with any commits resolved.
func (o SourceProvenanceResponseOutput) GitUri() pulumi.StringOutput {
	return o.ApplyT(func(v SourceProvenanceResponse) string { return v.GitUri }).(pulumi.StringOutput)
}

// A copy of the build's `source.repo_source`, if exists, with any revisions resolved.
func (o SourceProvenanceResponseOutput) ResolvedRepoSource() RepoSourceResponseOutput {
	return o.ApplyT(func(v SourceProvenanceResponse) RepoSourceResponse { return v.ResolvedRepoSource }).(RepoSourceResponseOutput)
}

// A copy of the build's `source.storage_source`, if exists, with any generations resolved.
func (o SourceProvenanceResponseOutput) ResolvedStorageSource() StorageSourceResponseOutput {
	return o.ApplyT(func(v SourceProvenanceResponse) StorageSourceResponse { return v.ResolvedStorageSource }).(StorageSourceResponseOutput)
}

// The location of the function source code.
type SourceResponse struct {
	// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
	GitUri string `pulumi:"gitUri"`
	// If provided, get the source from this location in a Cloud Source Repository.
	RepoSource RepoSourceResponse `pulumi:"repoSource"`
	// If provided, get the source from this location in Google Cloud Storage.
	StorageSource StorageSourceResponse `pulumi:"storageSource"`
}

// The location of the function source code.
type SourceResponseOutput struct{ *pulumi.OutputState }

func (SourceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SourceResponse)(nil)).Elem()
}

func (o SourceResponseOutput) ToSourceResponseOutput() SourceResponseOutput {
	return o
}

func (o SourceResponseOutput) ToSourceResponseOutputWithContext(ctx context.Context) SourceResponseOutput {
	return o
}

// If provided, get the source from GitHub repository. This option is valid only for GCF 1st Gen function. Example: https://github.com///blob//
func (o SourceResponseOutput) GitUri() pulumi.StringOutput {
	return o.ApplyT(func(v SourceResponse) string { return v.GitUri }).(pulumi.StringOutput)
}

// If provided, get the source from this location in a Cloud Source Repository.
func (o SourceResponseOutput) RepoSource() RepoSourceResponseOutput {
	return o.ApplyT(func(v SourceResponse) RepoSourceResponse { return v.RepoSource }).(RepoSourceResponseOutput)
}

// If provided, get the source from this location in Google Cloud Storage.
func (o SourceResponseOutput) StorageSource() StorageSourceResponseOutput {
	return o.ApplyT(func(v SourceResponse) StorageSourceResponse { return v.StorageSource }).(StorageSourceResponseOutput)
}

// Location of the source in an archive file in Google Cloud Storage.
type StorageSource struct {
	// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
	Bucket *string `pulumi:"bucket"`
	// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
	Generation *string `pulumi:"generation"`
	// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
	Object *string `pulumi:"object"`
}

// StorageSourceInput is an input type that accepts StorageSourceArgs and StorageSourceOutput values.
// You can construct a concrete instance of `StorageSourceInput` via:
//
//	StorageSourceArgs{...}
type StorageSourceInput interface {
	pulumi.Input

	ToStorageSourceOutput() StorageSourceOutput
	ToStorageSourceOutputWithContext(context.Context) StorageSourceOutput
}

// Location of the source in an archive file in Google Cloud Storage.
type StorageSourceArgs struct {
	// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
	Bucket pulumi.StringPtrInput `pulumi:"bucket"`
	// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
	Generation pulumi.StringPtrInput `pulumi:"generation"`
	// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
	Object pulumi.StringPtrInput `pulumi:"object"`
}

func (StorageSourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*StorageSource)(nil)).Elem()
}

func (i StorageSourceArgs) ToStorageSourceOutput() StorageSourceOutput {
	return i.ToStorageSourceOutputWithContext(context.Background())
}

func (i StorageSourceArgs) ToStorageSourceOutputWithContext(ctx context.Context) StorageSourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StorageSourceOutput)
}

func (i StorageSourceArgs) ToStorageSourcePtrOutput() StorageSourcePtrOutput {
	return i.ToStorageSourcePtrOutputWithContext(context.Background())
}

func (i StorageSourceArgs) ToStorageSourcePtrOutputWithContext(ctx context.Context) StorageSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StorageSourceOutput).ToStorageSourcePtrOutputWithContext(ctx)
}

// StorageSourcePtrInput is an input type that accepts StorageSourceArgs, StorageSourcePtr and StorageSourcePtrOutput values.
// You can construct a concrete instance of `StorageSourcePtrInput` via:
//
//	        StorageSourceArgs{...}
//
//	or:
//
//	        nil
type StorageSourcePtrInput interface {
	pulumi.Input

	ToStorageSourcePtrOutput() StorageSourcePtrOutput
	ToStorageSourcePtrOutputWithContext(context.Context) StorageSourcePtrOutput
}

type storageSourcePtrType StorageSourceArgs

func StorageSourcePtr(v *StorageSourceArgs) StorageSourcePtrInput {
	return (*storageSourcePtrType)(v)
}

func (*storageSourcePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**StorageSource)(nil)).Elem()
}

func (i *storageSourcePtrType) ToStorageSourcePtrOutput() StorageSourcePtrOutput {
	return i.ToStorageSourcePtrOutputWithContext(context.Background())
}

func (i *storageSourcePtrType) ToStorageSourcePtrOutputWithContext(ctx context.Context) StorageSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StorageSourcePtrOutput)
}

// Location of the source in an archive file in Google Cloud Storage.
type StorageSourceOutput struct{ *pulumi.OutputState }

func (StorageSourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*StorageSource)(nil)).Elem()
}

func (o StorageSourceOutput) ToStorageSourceOutput() StorageSourceOutput {
	return o
}

func (o StorageSourceOutput) ToStorageSourceOutputWithContext(ctx context.Context) StorageSourceOutput {
	return o
}

func (o StorageSourceOutput) ToStorageSourcePtrOutput() StorageSourcePtrOutput {
	return o.ToStorageSourcePtrOutputWithContext(context.Background())
}

func (o StorageSourceOutput) ToStorageSourcePtrOutputWithContext(ctx context.Context) StorageSourcePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v StorageSource) *StorageSource {
		return &v
	}).(StorageSourcePtrOutput)
}

// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
func (o StorageSourceOutput) Bucket() pulumi.StringPtrOutput {
	return o.ApplyT(func(v StorageSource) *string { return v.Bucket }).(pulumi.StringPtrOutput)
}

// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
func (o StorageSourceOutput) Generation() pulumi.StringPtrOutput {
	return o.ApplyT(func(v StorageSource) *string { return v.Generation }).(pulumi.StringPtrOutput)
}

// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
func (o StorageSourceOutput) Object() pulumi.StringPtrOutput {
	return o.ApplyT(func(v StorageSource) *string { return v.Object }).(pulumi.StringPtrOutput)
}

type StorageSourcePtrOutput struct{ *pulumi.OutputState }

func (StorageSourcePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**StorageSource)(nil)).Elem()
}

func (o StorageSourcePtrOutput) ToStorageSourcePtrOutput() StorageSourcePtrOutput {
	return o
}

func (o StorageSourcePtrOutput) ToStorageSourcePtrOutputWithContext(ctx context.Context) StorageSourcePtrOutput {
	return o
}

func (o StorageSourcePtrOutput) Elem() StorageSourceOutput {
	return o.ApplyT(func(v *StorageSource) StorageSource {
		if v != nil {
			return *v
		}
		var ret StorageSource
		return ret
	}).(StorageSourceOutput)
}

// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
func (o StorageSourcePtrOutput) Bucket() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *StorageSource) *string {
		if v == nil {
			return nil
		}
		return v.Bucket
	}).(pulumi.StringPtrOutput)
}

// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
func (o StorageSourcePtrOutput) Generation() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *StorageSource) *string {
		if v == nil {
			return nil
		}
		return v.Generation
	}).(pulumi.StringPtrOutput)
}

// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
func (o StorageSourcePtrOutput) Object() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *StorageSource) *string {
		if v == nil {
			return nil
		}
		return v.Object
	}).(pulumi.StringPtrOutput)
}

// Location of the source in an archive file in Google Cloud Storage.
type StorageSourceResponse struct {
	// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
	Bucket string `pulumi:"bucket"`
	// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
	Generation string `pulumi:"generation"`
	// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
	Object string `pulumi:"object"`
}

// Location of the source in an archive file in Google Cloud Storage.
type StorageSourceResponseOutput struct{ *pulumi.OutputState }

func (StorageSourceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*StorageSourceResponse)(nil)).Elem()
}

func (o StorageSourceResponseOutput) ToStorageSourceResponseOutput() StorageSourceResponseOutput {
	return o
}

func (o StorageSourceResponseOutput) ToStorageSourceResponseOutputWithContext(ctx context.Context) StorageSourceResponseOutput {
	return o
}

// Google Cloud Storage bucket containing the source (see [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
func (o StorageSourceResponseOutput) Bucket() pulumi.StringOutput {
	return o.ApplyT(func(v StorageSourceResponse) string { return v.Bucket }).(pulumi.StringOutput)
}

// Google Cloud Storage generation for the object. If the generation is omitted, the latest generation will be used.
func (o StorageSourceResponseOutput) Generation() pulumi.StringOutput {
	return o.ApplyT(func(v StorageSourceResponse) string { return v.Generation }).(pulumi.StringOutput)
}

// Google Cloud Storage object containing the source. This object must be a gzipped archive file (`.tar.gz`) containing source to build.
func (o StorageSourceResponseOutput) Object() pulumi.StringOutput {
	return o.ApplyT(func(v StorageSourceResponse) string { return v.Object }).(pulumi.StringOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AuditConfigInput)(nil)).Elem(), AuditConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AuditConfigArrayInput)(nil)).Elem(), AuditConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*AuditLogConfigInput)(nil)).Elem(), AuditLogConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AuditLogConfigArrayInput)(nil)).Elem(), AuditLogConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*BindingInput)(nil)).Elem(), BindingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*BindingArrayInput)(nil)).Elem(), BindingArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*BuildConfigInput)(nil)).Elem(), BuildConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*BuildConfigPtrInput)(nil)).Elem(), BuildConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventFilterInput)(nil)).Elem(), EventFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventFilterArrayInput)(nil)).Elem(), EventFilterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventTriggerInput)(nil)).Elem(), EventTriggerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventTriggerPtrInput)(nil)).Elem(), EventTriggerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ExprInput)(nil)).Elem(), ExprArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ExprPtrInput)(nil)).Elem(), ExprArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepoSourceInput)(nil)).Elem(), RepoSourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepoSourcePtrInput)(nil)).Elem(), RepoSourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretEnvVarInput)(nil)).Elem(), SecretEnvVarArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretEnvVarArrayInput)(nil)).Elem(), SecretEnvVarArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretVersionInput)(nil)).Elem(), SecretVersionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretVersionArrayInput)(nil)).Elem(), SecretVersionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretVolumeInput)(nil)).Elem(), SecretVolumeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SecretVolumeArrayInput)(nil)).Elem(), SecretVolumeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceConfigInput)(nil)).Elem(), ServiceConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceConfigPtrInput)(nil)).Elem(), ServiceConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SourceInput)(nil)).Elem(), SourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SourcePtrInput)(nil)).Elem(), SourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*StorageSourceInput)(nil)).Elem(), StorageSourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*StorageSourcePtrInput)(nil)).Elem(), StorageSourceArgs{})
	pulumi.RegisterOutputType(AuditConfigOutput{})
	pulumi.RegisterOutputType(AuditConfigArrayOutput{})
	pulumi.RegisterOutputType(AuditConfigResponseOutput{})
	pulumi.RegisterOutputType(AuditConfigResponseArrayOutput{})
	pulumi.RegisterOutputType(AuditLogConfigOutput{})
	pulumi.RegisterOutputType(AuditLogConfigArrayOutput{})
	pulumi.RegisterOutputType(AuditLogConfigResponseOutput{})
	pulumi.RegisterOutputType(AuditLogConfigResponseArrayOutput{})
	pulumi.RegisterOutputType(BindingOutput{})
	pulumi.RegisterOutputType(BindingArrayOutput{})
	pulumi.RegisterOutputType(BindingResponseOutput{})
	pulumi.RegisterOutputType(BindingResponseArrayOutput{})
	pulumi.RegisterOutputType(BuildConfigOutput{})
	pulumi.RegisterOutputType(BuildConfigPtrOutput{})
	pulumi.RegisterOutputType(BuildConfigResponseOutput{})
	pulumi.RegisterOutputType(EventFilterOutput{})
	pulumi.RegisterOutputType(EventFilterArrayOutput{})
	pulumi.RegisterOutputType(EventFilterResponseOutput{})
	pulumi.RegisterOutputType(EventFilterResponseArrayOutput{})
	pulumi.RegisterOutputType(EventTriggerOutput{})
	pulumi.RegisterOutputType(EventTriggerPtrOutput{})
	pulumi.RegisterOutputType(EventTriggerResponseOutput{})
	pulumi.RegisterOutputType(ExprOutput{})
	pulumi.RegisterOutputType(ExprPtrOutput{})
	pulumi.RegisterOutputType(ExprResponseOutput{})
	pulumi.RegisterOutputType(GoogleCloudFunctionsV2betaStateMessageResponseOutput{})
	pulumi.RegisterOutputType(GoogleCloudFunctionsV2betaStateMessageResponseArrayOutput{})
	pulumi.RegisterOutputType(RepoSourceOutput{})
	pulumi.RegisterOutputType(RepoSourcePtrOutput{})
	pulumi.RegisterOutputType(RepoSourceResponseOutput{})
	pulumi.RegisterOutputType(SecretEnvVarOutput{})
	pulumi.RegisterOutputType(SecretEnvVarArrayOutput{})
	pulumi.RegisterOutputType(SecretEnvVarResponseOutput{})
	pulumi.RegisterOutputType(SecretEnvVarResponseArrayOutput{})
	pulumi.RegisterOutputType(SecretVersionOutput{})
	pulumi.RegisterOutputType(SecretVersionArrayOutput{})
	pulumi.RegisterOutputType(SecretVersionResponseOutput{})
	pulumi.RegisterOutputType(SecretVersionResponseArrayOutput{})
	pulumi.RegisterOutputType(SecretVolumeOutput{})
	pulumi.RegisterOutputType(SecretVolumeArrayOutput{})
	pulumi.RegisterOutputType(SecretVolumeResponseOutput{})
	pulumi.RegisterOutputType(SecretVolumeResponseArrayOutput{})
	pulumi.RegisterOutputType(ServiceConfigOutput{})
	pulumi.RegisterOutputType(ServiceConfigPtrOutput{})
	pulumi.RegisterOutputType(ServiceConfigResponseOutput{})
	pulumi.RegisterOutputType(SourceOutput{})
	pulumi.RegisterOutputType(SourcePtrOutput{})
	pulumi.RegisterOutputType(SourceProvenanceResponseOutput{})
	pulumi.RegisterOutputType(SourceResponseOutput{})
	pulumi.RegisterOutputType(StorageSourceOutput{})
	pulumi.RegisterOutputType(StorageSourcePtrOutput{})
	pulumi.RegisterOutputType(StorageSourceResponseOutput{})
}