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 v1beta1

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)
}

// Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
type CloudSqlConnectionProfile struct {
	// Immutable. Metadata used to create the destination Cloud SQL database.
	Settings *CloudSqlSettings `pulumi:"settings"`
}

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

	ToCloudSqlConnectionProfileOutput() CloudSqlConnectionProfileOutput
	ToCloudSqlConnectionProfileOutputWithContext(context.Context) CloudSqlConnectionProfileOutput
}

// Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
type CloudSqlConnectionProfileArgs struct {
	// Immutable. Metadata used to create the destination Cloud SQL database.
	Settings CloudSqlSettingsPtrInput `pulumi:"settings"`
}

func (CloudSqlConnectionProfileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlConnectionProfile)(nil)).Elem()
}

func (i CloudSqlConnectionProfileArgs) ToCloudSqlConnectionProfileOutput() CloudSqlConnectionProfileOutput {
	return i.ToCloudSqlConnectionProfileOutputWithContext(context.Background())
}

func (i CloudSqlConnectionProfileArgs) ToCloudSqlConnectionProfileOutputWithContext(ctx context.Context) CloudSqlConnectionProfileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlConnectionProfileOutput)
}

func (i CloudSqlConnectionProfileArgs) ToCloudSqlConnectionProfilePtrOutput() CloudSqlConnectionProfilePtrOutput {
	return i.ToCloudSqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (i CloudSqlConnectionProfileArgs) ToCloudSqlConnectionProfilePtrOutputWithContext(ctx context.Context) CloudSqlConnectionProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlConnectionProfileOutput).ToCloudSqlConnectionProfilePtrOutputWithContext(ctx)
}

// CloudSqlConnectionProfilePtrInput is an input type that accepts CloudSqlConnectionProfileArgs, CloudSqlConnectionProfilePtr and CloudSqlConnectionProfilePtrOutput values.
// You can construct a concrete instance of `CloudSqlConnectionProfilePtrInput` via:
//
//	        CloudSqlConnectionProfileArgs{...}
//
//	or:
//
//	        nil
type CloudSqlConnectionProfilePtrInput interface {
	pulumi.Input

	ToCloudSqlConnectionProfilePtrOutput() CloudSqlConnectionProfilePtrOutput
	ToCloudSqlConnectionProfilePtrOutputWithContext(context.Context) CloudSqlConnectionProfilePtrOutput
}

type cloudSqlConnectionProfilePtrType CloudSqlConnectionProfileArgs

func CloudSqlConnectionProfilePtr(v *CloudSqlConnectionProfileArgs) CloudSqlConnectionProfilePtrInput {
	return (*cloudSqlConnectionProfilePtrType)(v)
}

func (*cloudSqlConnectionProfilePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CloudSqlConnectionProfile)(nil)).Elem()
}

func (i *cloudSqlConnectionProfilePtrType) ToCloudSqlConnectionProfilePtrOutput() CloudSqlConnectionProfilePtrOutput {
	return i.ToCloudSqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (i *cloudSqlConnectionProfilePtrType) ToCloudSqlConnectionProfilePtrOutputWithContext(ctx context.Context) CloudSqlConnectionProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlConnectionProfilePtrOutput)
}

// Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
type CloudSqlConnectionProfileOutput struct{ *pulumi.OutputState }

func (CloudSqlConnectionProfileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlConnectionProfile)(nil)).Elem()
}

func (o CloudSqlConnectionProfileOutput) ToCloudSqlConnectionProfileOutput() CloudSqlConnectionProfileOutput {
	return o
}

func (o CloudSqlConnectionProfileOutput) ToCloudSqlConnectionProfileOutputWithContext(ctx context.Context) CloudSqlConnectionProfileOutput {
	return o
}

func (o CloudSqlConnectionProfileOutput) ToCloudSqlConnectionProfilePtrOutput() CloudSqlConnectionProfilePtrOutput {
	return o.ToCloudSqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (o CloudSqlConnectionProfileOutput) ToCloudSqlConnectionProfilePtrOutputWithContext(ctx context.Context) CloudSqlConnectionProfilePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v CloudSqlConnectionProfile) *CloudSqlConnectionProfile {
		return &v
	}).(CloudSqlConnectionProfilePtrOutput)
}

// Immutable. Metadata used to create the destination Cloud SQL database.
func (o CloudSqlConnectionProfileOutput) Settings() CloudSqlSettingsPtrOutput {
	return o.ApplyT(func(v CloudSqlConnectionProfile) *CloudSqlSettings { return v.Settings }).(CloudSqlSettingsPtrOutput)
}

type CloudSqlConnectionProfilePtrOutput struct{ *pulumi.OutputState }

func (CloudSqlConnectionProfilePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CloudSqlConnectionProfile)(nil)).Elem()
}

func (o CloudSqlConnectionProfilePtrOutput) ToCloudSqlConnectionProfilePtrOutput() CloudSqlConnectionProfilePtrOutput {
	return o
}

func (o CloudSqlConnectionProfilePtrOutput) ToCloudSqlConnectionProfilePtrOutputWithContext(ctx context.Context) CloudSqlConnectionProfilePtrOutput {
	return o
}

func (o CloudSqlConnectionProfilePtrOutput) Elem() CloudSqlConnectionProfileOutput {
	return o.ApplyT(func(v *CloudSqlConnectionProfile) CloudSqlConnectionProfile {
		if v != nil {
			return *v
		}
		var ret CloudSqlConnectionProfile
		return ret
	}).(CloudSqlConnectionProfileOutput)
}

// Immutable. Metadata used to create the destination Cloud SQL database.
func (o CloudSqlConnectionProfilePtrOutput) Settings() CloudSqlSettingsPtrOutput {
	return o.ApplyT(func(v *CloudSqlConnectionProfile) *CloudSqlSettings {
		if v == nil {
			return nil
		}
		return v.Settings
	}).(CloudSqlSettingsPtrOutput)
}

// Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
type CloudSqlConnectionProfileResponse struct {
	// The Cloud SQL instance ID that this connection profile is associated with.
	CloudSqlId string `pulumi:"cloudSqlId"`
	// The Cloud SQL database instance's private IP.
	PrivateIp string `pulumi:"privateIp"`
	// The Cloud SQL database instance's public IP.
	PublicIp string `pulumi:"publicIp"`
	// Immutable. Metadata used to create the destination Cloud SQL database.
	Settings CloudSqlSettingsResponse `pulumi:"settings"`
}

// Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
type CloudSqlConnectionProfileResponseOutput struct{ *pulumi.OutputState }

func (CloudSqlConnectionProfileResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlConnectionProfileResponse)(nil)).Elem()
}

func (o CloudSqlConnectionProfileResponseOutput) ToCloudSqlConnectionProfileResponseOutput() CloudSqlConnectionProfileResponseOutput {
	return o
}

func (o CloudSqlConnectionProfileResponseOutput) ToCloudSqlConnectionProfileResponseOutputWithContext(ctx context.Context) CloudSqlConnectionProfileResponseOutput {
	return o
}

// The Cloud SQL instance ID that this connection profile is associated with.
func (o CloudSqlConnectionProfileResponseOutput) CloudSqlId() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlConnectionProfileResponse) string { return v.CloudSqlId }).(pulumi.StringOutput)
}

// The Cloud SQL database instance's private IP.
func (o CloudSqlConnectionProfileResponseOutput) PrivateIp() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlConnectionProfileResponse) string { return v.PrivateIp }).(pulumi.StringOutput)
}

// The Cloud SQL database instance's public IP.
func (o CloudSqlConnectionProfileResponseOutput) PublicIp() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlConnectionProfileResponse) string { return v.PublicIp }).(pulumi.StringOutput)
}

// Immutable. Metadata used to create the destination Cloud SQL database.
func (o CloudSqlConnectionProfileResponseOutput) Settings() CloudSqlSettingsResponseOutput {
	return o.ApplyT(func(v CloudSqlConnectionProfileResponse) CloudSqlSettingsResponse { return v.Settings }).(CloudSqlSettingsResponseOutput)
}

// Settings for creating a Cloud SQL database instance.
type CloudSqlSettings struct {
	// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
	ActivationPolicy *CloudSqlSettingsActivationPolicy `pulumi:"activationPolicy"`
	// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
	AutoStorageIncrease *bool `pulumi:"autoStorageIncrease"`
	// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
	DataDiskSizeGb *string `pulumi:"dataDiskSizeGb"`
	// The type of storage: `PD_SSD` (default) or `PD_HDD`.
	DataDiskType *CloudSqlSettingsDataDiskType `pulumi:"dataDiskType"`
	// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
	DatabaseFlags map[string]string `pulumi:"databaseFlags"`
	// The database engine type and version.
	DatabaseVersion *CloudSqlSettingsDatabaseVersion `pulumi:"databaseVersion"`
	// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
	IpConfig *SqlIpConfig `pulumi:"ipConfig"`
	// Input only. Initial root password.
	RootPassword *string `pulumi:"rootPassword"`
	// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
	SourceId *string `pulumi:"sourceId"`
	// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
	StorageAutoResizeLimit *string `pulumi:"storageAutoResizeLimit"`
	// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
	Tier *string `pulumi:"tier"`
	// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
	UserLabels map[string]string `pulumi:"userLabels"`
	// The Google Cloud Platform zone where your Cloud SQL database instance is located.
	Zone *string `pulumi:"zone"`
}

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

	ToCloudSqlSettingsOutput() CloudSqlSettingsOutput
	ToCloudSqlSettingsOutputWithContext(context.Context) CloudSqlSettingsOutput
}

// Settings for creating a Cloud SQL database instance.
type CloudSqlSettingsArgs struct {
	// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
	ActivationPolicy CloudSqlSettingsActivationPolicyPtrInput `pulumi:"activationPolicy"`
	// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
	AutoStorageIncrease pulumi.BoolPtrInput `pulumi:"autoStorageIncrease"`
	// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
	DataDiskSizeGb pulumi.StringPtrInput `pulumi:"dataDiskSizeGb"`
	// The type of storage: `PD_SSD` (default) or `PD_HDD`.
	DataDiskType CloudSqlSettingsDataDiskTypePtrInput `pulumi:"dataDiskType"`
	// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
	DatabaseFlags pulumi.StringMapInput `pulumi:"databaseFlags"`
	// The database engine type and version.
	DatabaseVersion CloudSqlSettingsDatabaseVersionPtrInput `pulumi:"databaseVersion"`
	// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
	IpConfig SqlIpConfigPtrInput `pulumi:"ipConfig"`
	// Input only. Initial root password.
	RootPassword pulumi.StringPtrInput `pulumi:"rootPassword"`
	// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
	SourceId pulumi.StringPtrInput `pulumi:"sourceId"`
	// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
	StorageAutoResizeLimit pulumi.StringPtrInput `pulumi:"storageAutoResizeLimit"`
	// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
	Tier pulumi.StringPtrInput `pulumi:"tier"`
	// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
	UserLabels pulumi.StringMapInput `pulumi:"userLabels"`
	// The Google Cloud Platform zone where your Cloud SQL database instance is located.
	Zone pulumi.StringPtrInput `pulumi:"zone"`
}

func (CloudSqlSettingsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlSettings)(nil)).Elem()
}

func (i CloudSqlSettingsArgs) ToCloudSqlSettingsOutput() CloudSqlSettingsOutput {
	return i.ToCloudSqlSettingsOutputWithContext(context.Background())
}

func (i CloudSqlSettingsArgs) ToCloudSqlSettingsOutputWithContext(ctx context.Context) CloudSqlSettingsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlSettingsOutput)
}

func (i CloudSqlSettingsArgs) ToCloudSqlSettingsPtrOutput() CloudSqlSettingsPtrOutput {
	return i.ToCloudSqlSettingsPtrOutputWithContext(context.Background())
}

func (i CloudSqlSettingsArgs) ToCloudSqlSettingsPtrOutputWithContext(ctx context.Context) CloudSqlSettingsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlSettingsOutput).ToCloudSqlSettingsPtrOutputWithContext(ctx)
}

// CloudSqlSettingsPtrInput is an input type that accepts CloudSqlSettingsArgs, CloudSqlSettingsPtr and CloudSqlSettingsPtrOutput values.
// You can construct a concrete instance of `CloudSqlSettingsPtrInput` via:
//
//	        CloudSqlSettingsArgs{...}
//
//	or:
//
//	        nil
type CloudSqlSettingsPtrInput interface {
	pulumi.Input

	ToCloudSqlSettingsPtrOutput() CloudSqlSettingsPtrOutput
	ToCloudSqlSettingsPtrOutputWithContext(context.Context) CloudSqlSettingsPtrOutput
}

type cloudSqlSettingsPtrType CloudSqlSettingsArgs

func CloudSqlSettingsPtr(v *CloudSqlSettingsArgs) CloudSqlSettingsPtrInput {
	return (*cloudSqlSettingsPtrType)(v)
}

func (*cloudSqlSettingsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**CloudSqlSettings)(nil)).Elem()
}

func (i *cloudSqlSettingsPtrType) ToCloudSqlSettingsPtrOutput() CloudSqlSettingsPtrOutput {
	return i.ToCloudSqlSettingsPtrOutputWithContext(context.Background())
}

func (i *cloudSqlSettingsPtrType) ToCloudSqlSettingsPtrOutputWithContext(ctx context.Context) CloudSqlSettingsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(CloudSqlSettingsPtrOutput)
}

// Settings for creating a Cloud SQL database instance.
type CloudSqlSettingsOutput struct{ *pulumi.OutputState }

func (CloudSqlSettingsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlSettings)(nil)).Elem()
}

func (o CloudSqlSettingsOutput) ToCloudSqlSettingsOutput() CloudSqlSettingsOutput {
	return o
}

func (o CloudSqlSettingsOutput) ToCloudSqlSettingsOutputWithContext(ctx context.Context) CloudSqlSettingsOutput {
	return o
}

func (o CloudSqlSettingsOutput) ToCloudSqlSettingsPtrOutput() CloudSqlSettingsPtrOutput {
	return o.ToCloudSqlSettingsPtrOutputWithContext(context.Background())
}

func (o CloudSqlSettingsOutput) ToCloudSqlSettingsPtrOutputWithContext(ctx context.Context) CloudSqlSettingsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v CloudSqlSettings) *CloudSqlSettings {
		return &v
	}).(CloudSqlSettingsPtrOutput)
}

// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
func (o CloudSqlSettingsOutput) ActivationPolicy() CloudSqlSettingsActivationPolicyPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *CloudSqlSettingsActivationPolicy { return v.ActivationPolicy }).(CloudSqlSettingsActivationPolicyPtrOutput)
}

// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
func (o CloudSqlSettingsOutput) AutoStorageIncrease() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *bool { return v.AutoStorageIncrease }).(pulumi.BoolPtrOutput)
}

// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
func (o CloudSqlSettingsOutput) DataDiskSizeGb() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.DataDiskSizeGb }).(pulumi.StringPtrOutput)
}

// The type of storage: `PD_SSD` (default) or `PD_HDD`.
func (o CloudSqlSettingsOutput) DataDiskType() CloudSqlSettingsDataDiskTypePtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *CloudSqlSettingsDataDiskType { return v.DataDiskType }).(CloudSqlSettingsDataDiskTypePtrOutput)
}

// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
func (o CloudSqlSettingsOutput) DatabaseFlags() pulumi.StringMapOutput {
	return o.ApplyT(func(v CloudSqlSettings) map[string]string { return v.DatabaseFlags }).(pulumi.StringMapOutput)
}

// The database engine type and version.
func (o CloudSqlSettingsOutput) DatabaseVersion() CloudSqlSettingsDatabaseVersionPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *CloudSqlSettingsDatabaseVersion { return v.DatabaseVersion }).(CloudSqlSettingsDatabaseVersionPtrOutput)
}

// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
func (o CloudSqlSettingsOutput) IpConfig() SqlIpConfigPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *SqlIpConfig { return v.IpConfig }).(SqlIpConfigPtrOutput)
}

// Input only. Initial root password.
func (o CloudSqlSettingsOutput) RootPassword() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.RootPassword }).(pulumi.StringPtrOutput)
}

// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
func (o CloudSqlSettingsOutput) SourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.SourceId }).(pulumi.StringPtrOutput)
}

// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
func (o CloudSqlSettingsOutput) StorageAutoResizeLimit() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.StorageAutoResizeLimit }).(pulumi.StringPtrOutput)
}

// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
func (o CloudSqlSettingsOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.Tier }).(pulumi.StringPtrOutput)
}

// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
func (o CloudSqlSettingsOutput) UserLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v CloudSqlSettings) map[string]string { return v.UserLabels }).(pulumi.StringMapOutput)
}

// The Google Cloud Platform zone where your Cloud SQL database instance is located.
func (o CloudSqlSettingsOutput) Zone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v CloudSqlSettings) *string { return v.Zone }).(pulumi.StringPtrOutput)
}

type CloudSqlSettingsPtrOutput struct{ *pulumi.OutputState }

func (CloudSqlSettingsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**CloudSqlSettings)(nil)).Elem()
}

func (o CloudSqlSettingsPtrOutput) ToCloudSqlSettingsPtrOutput() CloudSqlSettingsPtrOutput {
	return o
}

func (o CloudSqlSettingsPtrOutput) ToCloudSqlSettingsPtrOutputWithContext(ctx context.Context) CloudSqlSettingsPtrOutput {
	return o
}

func (o CloudSqlSettingsPtrOutput) Elem() CloudSqlSettingsOutput {
	return o.ApplyT(func(v *CloudSqlSettings) CloudSqlSettings {
		if v != nil {
			return *v
		}
		var ret CloudSqlSettings
		return ret
	}).(CloudSqlSettingsOutput)
}

// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
func (o CloudSqlSettingsPtrOutput) ActivationPolicy() CloudSqlSettingsActivationPolicyPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *CloudSqlSettingsActivationPolicy {
		if v == nil {
			return nil
		}
		return v.ActivationPolicy
	}).(CloudSqlSettingsActivationPolicyPtrOutput)
}

// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
func (o CloudSqlSettingsPtrOutput) AutoStorageIncrease() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *bool {
		if v == nil {
			return nil
		}
		return v.AutoStorageIncrease
	}).(pulumi.BoolPtrOutput)
}

// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
func (o CloudSqlSettingsPtrOutput) DataDiskSizeGb() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.DataDiskSizeGb
	}).(pulumi.StringPtrOutput)
}

// The type of storage: `PD_SSD` (default) or `PD_HDD`.
func (o CloudSqlSettingsPtrOutput) DataDiskType() CloudSqlSettingsDataDiskTypePtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *CloudSqlSettingsDataDiskType {
		if v == nil {
			return nil
		}
		return v.DataDiskType
	}).(CloudSqlSettingsDataDiskTypePtrOutput)
}

// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
func (o CloudSqlSettingsPtrOutput) DatabaseFlags() pulumi.StringMapOutput {
	return o.ApplyT(func(v *CloudSqlSettings) map[string]string {
		if v == nil {
			return nil
		}
		return v.DatabaseFlags
	}).(pulumi.StringMapOutput)
}

// The database engine type and version.
func (o CloudSqlSettingsPtrOutput) DatabaseVersion() CloudSqlSettingsDatabaseVersionPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *CloudSqlSettingsDatabaseVersion {
		if v == nil {
			return nil
		}
		return v.DatabaseVersion
	}).(CloudSqlSettingsDatabaseVersionPtrOutput)
}

// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
func (o CloudSqlSettingsPtrOutput) IpConfig() SqlIpConfigPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *SqlIpConfig {
		if v == nil {
			return nil
		}
		return v.IpConfig
	}).(SqlIpConfigPtrOutput)
}

// Input only. Initial root password.
func (o CloudSqlSettingsPtrOutput) RootPassword() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.RootPassword
	}).(pulumi.StringPtrOutput)
}

// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
func (o CloudSqlSettingsPtrOutput) SourceId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.SourceId
	}).(pulumi.StringPtrOutput)
}

// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
func (o CloudSqlSettingsPtrOutput) StorageAutoResizeLimit() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.StorageAutoResizeLimit
	}).(pulumi.StringPtrOutput)
}

// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
func (o CloudSqlSettingsPtrOutput) Tier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.Tier
	}).(pulumi.StringPtrOutput)
}

// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
func (o CloudSqlSettingsPtrOutput) UserLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v *CloudSqlSettings) map[string]string {
		if v == nil {
			return nil
		}
		return v.UserLabels
	}).(pulumi.StringMapOutput)
}

// The Google Cloud Platform zone where your Cloud SQL database instance is located.
func (o CloudSqlSettingsPtrOutput) Zone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *CloudSqlSettings) *string {
		if v == nil {
			return nil
		}
		return v.Zone
	}).(pulumi.StringPtrOutput)
}

// Settings for creating a Cloud SQL database instance.
type CloudSqlSettingsResponse struct {
	// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
	ActivationPolicy string `pulumi:"activationPolicy"`
	// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
	AutoStorageIncrease bool `pulumi:"autoStorageIncrease"`
	// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
	DataDiskSizeGb string `pulumi:"dataDiskSizeGb"`
	// The type of storage: `PD_SSD` (default) or `PD_HDD`.
	DataDiskType string `pulumi:"dataDiskType"`
	// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
	DatabaseFlags map[string]string `pulumi:"databaseFlags"`
	// The database engine type and version.
	DatabaseVersion string `pulumi:"databaseVersion"`
	// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
	IpConfig SqlIpConfigResponse `pulumi:"ipConfig"`
	// Input only. Initial root password.
	RootPassword string `pulumi:"rootPassword"`
	// Indicates If this connection profile root password is stored.
	RootPasswordSet bool `pulumi:"rootPasswordSet"`
	// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
	SourceId string `pulumi:"sourceId"`
	// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
	StorageAutoResizeLimit string `pulumi:"storageAutoResizeLimit"`
	// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
	Tier string `pulumi:"tier"`
	// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
	UserLabels map[string]string `pulumi:"userLabels"`
	// The Google Cloud Platform zone where your Cloud SQL database instance is located.
	Zone string `pulumi:"zone"`
}

// Settings for creating a Cloud SQL database instance.
type CloudSqlSettingsResponseOutput struct{ *pulumi.OutputState }

func (CloudSqlSettingsResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*CloudSqlSettingsResponse)(nil)).Elem()
}

func (o CloudSqlSettingsResponseOutput) ToCloudSqlSettingsResponseOutput() CloudSqlSettingsResponseOutput {
	return o
}

func (o CloudSqlSettingsResponseOutput) ToCloudSqlSettingsResponseOutputWithContext(ctx context.Context) CloudSqlSettingsResponseOutput {
	return o
}

// The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
func (o CloudSqlSettingsResponseOutput) ActivationPolicy() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.ActivationPolicy }).(pulumi.StringOutput)
}

// [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
func (o CloudSqlSettingsResponseOutput) AutoStorageIncrease() pulumi.BoolOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) bool { return v.AutoStorageIncrease }).(pulumi.BoolOutput)
}

// The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
func (o CloudSqlSettingsResponseOutput) DataDiskSizeGb() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.DataDiskSizeGb }).(pulumi.StringOutput)
}

// The type of storage: `PD_SSD` (default) or `PD_HDD`.
func (o CloudSqlSettingsResponseOutput) DataDiskType() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.DataDiskType }).(pulumi.StringOutput)
}

// The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
func (o CloudSqlSettingsResponseOutput) DatabaseFlags() pulumi.StringMapOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) map[string]string { return v.DatabaseFlags }).(pulumi.StringMapOutput)
}

// The database engine type and version.
func (o CloudSqlSettingsResponseOutput) DatabaseVersion() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.DatabaseVersion }).(pulumi.StringOutput)
}

// The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
func (o CloudSqlSettingsResponseOutput) IpConfig() SqlIpConfigResponseOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) SqlIpConfigResponse { return v.IpConfig }).(SqlIpConfigResponseOutput)
}

// Input only. Initial root password.
func (o CloudSqlSettingsResponseOutput) RootPassword() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.RootPassword }).(pulumi.StringOutput)
}

// Indicates If this connection profile root password is stored.
func (o CloudSqlSettingsResponseOutput) RootPasswordSet() pulumi.BoolOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) bool { return v.RootPasswordSet }).(pulumi.BoolOutput)
}

// The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
func (o CloudSqlSettingsResponseOutput) SourceId() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.SourceId }).(pulumi.StringOutput)
}

// The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
func (o CloudSqlSettingsResponseOutput) StorageAutoResizeLimit() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.StorageAutoResizeLimit }).(pulumi.StringOutput)
}

// The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
func (o CloudSqlSettingsResponseOutput) Tier() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.Tier }).(pulumi.StringOutput)
}

// The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" }`.
func (o CloudSqlSettingsResponseOutput) UserLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) map[string]string { return v.UserLabels }).(pulumi.StringMapOutput)
}

// The Google Cloud Platform zone where your Cloud SQL database instance is located.
func (o CloudSqlSettingsResponseOutput) Zone() pulumi.StringOutput {
	return o.ApplyT(func(v CloudSqlSettingsResponse) string { return v.Zone }).(pulumi.StringOutput)
}

// A message defining the database engine and provider.
type DatabaseType struct {
	// The database engine.
	Engine *DatabaseTypeEngine `pulumi:"engine"`
	// The database provider.
	Provider *DatabaseTypeProvider `pulumi:"provider"`
}

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

	ToDatabaseTypeOutput() DatabaseTypeOutput
	ToDatabaseTypeOutputWithContext(context.Context) DatabaseTypeOutput
}

// A message defining the database engine and provider.
type DatabaseTypeArgs struct {
	// The database engine.
	Engine DatabaseTypeEnginePtrInput `pulumi:"engine"`
	// The database provider.
	Provider DatabaseTypeProviderPtrInput `pulumi:"provider"`
}

func (DatabaseTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DatabaseType)(nil)).Elem()
}

func (i DatabaseTypeArgs) ToDatabaseTypeOutput() DatabaseTypeOutput {
	return i.ToDatabaseTypeOutputWithContext(context.Background())
}

func (i DatabaseTypeArgs) ToDatabaseTypeOutputWithContext(ctx context.Context) DatabaseTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DatabaseTypeOutput)
}

func (i DatabaseTypeArgs) ToDatabaseTypePtrOutput() DatabaseTypePtrOutput {
	return i.ToDatabaseTypePtrOutputWithContext(context.Background())
}

func (i DatabaseTypeArgs) ToDatabaseTypePtrOutputWithContext(ctx context.Context) DatabaseTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DatabaseTypeOutput).ToDatabaseTypePtrOutputWithContext(ctx)
}

// DatabaseTypePtrInput is an input type that accepts DatabaseTypeArgs, DatabaseTypePtr and DatabaseTypePtrOutput values.
// You can construct a concrete instance of `DatabaseTypePtrInput` via:
//
//	        DatabaseTypeArgs{...}
//
//	or:
//
//	        nil
type DatabaseTypePtrInput interface {
	pulumi.Input

	ToDatabaseTypePtrOutput() DatabaseTypePtrOutput
	ToDatabaseTypePtrOutputWithContext(context.Context) DatabaseTypePtrOutput
}

type databaseTypePtrType DatabaseTypeArgs

func DatabaseTypePtr(v *DatabaseTypeArgs) DatabaseTypePtrInput {
	return (*databaseTypePtrType)(v)
}

func (*databaseTypePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DatabaseType)(nil)).Elem()
}

func (i *databaseTypePtrType) ToDatabaseTypePtrOutput() DatabaseTypePtrOutput {
	return i.ToDatabaseTypePtrOutputWithContext(context.Background())
}

func (i *databaseTypePtrType) ToDatabaseTypePtrOutputWithContext(ctx context.Context) DatabaseTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DatabaseTypePtrOutput)
}

// A message defining the database engine and provider.
type DatabaseTypeOutput struct{ *pulumi.OutputState }

func (DatabaseTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DatabaseType)(nil)).Elem()
}

func (o DatabaseTypeOutput) ToDatabaseTypeOutput() DatabaseTypeOutput {
	return o
}

func (o DatabaseTypeOutput) ToDatabaseTypeOutputWithContext(ctx context.Context) DatabaseTypeOutput {
	return o
}

func (o DatabaseTypeOutput) ToDatabaseTypePtrOutput() DatabaseTypePtrOutput {
	return o.ToDatabaseTypePtrOutputWithContext(context.Background())
}

func (o DatabaseTypeOutput) ToDatabaseTypePtrOutputWithContext(ctx context.Context) DatabaseTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DatabaseType) *DatabaseType {
		return &v
	}).(DatabaseTypePtrOutput)
}

// The database engine.
func (o DatabaseTypeOutput) Engine() DatabaseTypeEnginePtrOutput {
	return o.ApplyT(func(v DatabaseType) *DatabaseTypeEngine { return v.Engine }).(DatabaseTypeEnginePtrOutput)
}

// The database provider.
func (o DatabaseTypeOutput) Provider() DatabaseTypeProviderPtrOutput {
	return o.ApplyT(func(v DatabaseType) *DatabaseTypeProvider { return v.Provider }).(DatabaseTypeProviderPtrOutput)
}

type DatabaseTypePtrOutput struct{ *pulumi.OutputState }

func (DatabaseTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DatabaseType)(nil)).Elem()
}

func (o DatabaseTypePtrOutput) ToDatabaseTypePtrOutput() DatabaseTypePtrOutput {
	return o
}

func (o DatabaseTypePtrOutput) ToDatabaseTypePtrOutputWithContext(ctx context.Context) DatabaseTypePtrOutput {
	return o
}

func (o DatabaseTypePtrOutput) Elem() DatabaseTypeOutput {
	return o.ApplyT(func(v *DatabaseType) DatabaseType {
		if v != nil {
			return *v
		}
		var ret DatabaseType
		return ret
	}).(DatabaseTypeOutput)
}

// The database engine.
func (o DatabaseTypePtrOutput) Engine() DatabaseTypeEnginePtrOutput {
	return o.ApplyT(func(v *DatabaseType) *DatabaseTypeEngine {
		if v == nil {
			return nil
		}
		return v.Engine
	}).(DatabaseTypeEnginePtrOutput)
}

// The database provider.
func (o DatabaseTypePtrOutput) Provider() DatabaseTypeProviderPtrOutput {
	return o.ApplyT(func(v *DatabaseType) *DatabaseTypeProvider {
		if v == nil {
			return nil
		}
		return v.Provider
	}).(DatabaseTypeProviderPtrOutput)
}

// A message defining the database engine and provider.
type DatabaseTypeResponse struct {
	// The database engine.
	Engine string `pulumi:"engine"`
	// The database provider.
	Provider string `pulumi:"provider"`
}

// A message defining the database engine and provider.
type DatabaseTypeResponseOutput struct{ *pulumi.OutputState }

func (DatabaseTypeResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DatabaseTypeResponse)(nil)).Elem()
}

func (o DatabaseTypeResponseOutput) ToDatabaseTypeResponseOutput() DatabaseTypeResponseOutput {
	return o
}

func (o DatabaseTypeResponseOutput) ToDatabaseTypeResponseOutputWithContext(ctx context.Context) DatabaseTypeResponseOutput {
	return o
}

// The database engine.
func (o DatabaseTypeResponseOutput) Engine() pulumi.StringOutput {
	return o.ApplyT(func(v DatabaseTypeResponse) string { return v.Engine }).(pulumi.StringOutput)
}

// The database provider.
func (o DatabaseTypeResponseOutput) Provider() pulumi.StringOutput {
	return o.ApplyT(func(v DatabaseTypeResponse) string { return v.Provider }).(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)
}

// Specifies connection parameters required specifically for MySQL databases.
type MySqlConnectionProfile struct {
	// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
	CloudSqlId *string `pulumi:"cloudSqlId"`
	// The IP or hostname of the source MySQL database.
	Host string `pulumi:"host"`
	// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
	Password string `pulumi:"password"`
	// The network port of the source MySQL database.
	Port int `pulumi:"port"`
	// SSL configuration for the destination to connect to the source database.
	Ssl *SslConfig `pulumi:"ssl"`
	// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
	Username string `pulumi:"username"`
}

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

	ToMySqlConnectionProfileOutput() MySqlConnectionProfileOutput
	ToMySqlConnectionProfileOutputWithContext(context.Context) MySqlConnectionProfileOutput
}

// Specifies connection parameters required specifically for MySQL databases.
type MySqlConnectionProfileArgs struct {
	// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
	CloudSqlId pulumi.StringPtrInput `pulumi:"cloudSqlId"`
	// The IP or hostname of the source MySQL database.
	Host pulumi.StringInput `pulumi:"host"`
	// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
	Password pulumi.StringInput `pulumi:"password"`
	// The network port of the source MySQL database.
	Port pulumi.IntInput `pulumi:"port"`
	// SSL configuration for the destination to connect to the source database.
	Ssl SslConfigPtrInput `pulumi:"ssl"`
	// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
	Username pulumi.StringInput `pulumi:"username"`
}

func (MySqlConnectionProfileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*MySqlConnectionProfile)(nil)).Elem()
}

func (i MySqlConnectionProfileArgs) ToMySqlConnectionProfileOutput() MySqlConnectionProfileOutput {
	return i.ToMySqlConnectionProfileOutputWithContext(context.Background())
}

func (i MySqlConnectionProfileArgs) ToMySqlConnectionProfileOutputWithContext(ctx context.Context) MySqlConnectionProfileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MySqlConnectionProfileOutput)
}

func (i MySqlConnectionProfileArgs) ToMySqlConnectionProfilePtrOutput() MySqlConnectionProfilePtrOutput {
	return i.ToMySqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (i MySqlConnectionProfileArgs) ToMySqlConnectionProfilePtrOutputWithContext(ctx context.Context) MySqlConnectionProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MySqlConnectionProfileOutput).ToMySqlConnectionProfilePtrOutputWithContext(ctx)
}

// MySqlConnectionProfilePtrInput is an input type that accepts MySqlConnectionProfileArgs, MySqlConnectionProfilePtr and MySqlConnectionProfilePtrOutput values.
// You can construct a concrete instance of `MySqlConnectionProfilePtrInput` via:
//
//	        MySqlConnectionProfileArgs{...}
//
//	or:
//
//	        nil
type MySqlConnectionProfilePtrInput interface {
	pulumi.Input

	ToMySqlConnectionProfilePtrOutput() MySqlConnectionProfilePtrOutput
	ToMySqlConnectionProfilePtrOutputWithContext(context.Context) MySqlConnectionProfilePtrOutput
}

type mySqlConnectionProfilePtrType MySqlConnectionProfileArgs

func MySqlConnectionProfilePtr(v *MySqlConnectionProfileArgs) MySqlConnectionProfilePtrInput {
	return (*mySqlConnectionProfilePtrType)(v)
}

func (*mySqlConnectionProfilePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**MySqlConnectionProfile)(nil)).Elem()
}

func (i *mySqlConnectionProfilePtrType) ToMySqlConnectionProfilePtrOutput() MySqlConnectionProfilePtrOutput {
	return i.ToMySqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (i *mySqlConnectionProfilePtrType) ToMySqlConnectionProfilePtrOutputWithContext(ctx context.Context) MySqlConnectionProfilePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MySqlConnectionProfilePtrOutput)
}

// Specifies connection parameters required specifically for MySQL databases.
type MySqlConnectionProfileOutput struct{ *pulumi.OutputState }

func (MySqlConnectionProfileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*MySqlConnectionProfile)(nil)).Elem()
}

func (o MySqlConnectionProfileOutput) ToMySqlConnectionProfileOutput() MySqlConnectionProfileOutput {
	return o
}

func (o MySqlConnectionProfileOutput) ToMySqlConnectionProfileOutputWithContext(ctx context.Context) MySqlConnectionProfileOutput {
	return o
}

func (o MySqlConnectionProfileOutput) ToMySqlConnectionProfilePtrOutput() MySqlConnectionProfilePtrOutput {
	return o.ToMySqlConnectionProfilePtrOutputWithContext(context.Background())
}

func (o MySqlConnectionProfileOutput) ToMySqlConnectionProfilePtrOutputWithContext(ctx context.Context) MySqlConnectionProfilePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v MySqlConnectionProfile) *MySqlConnectionProfile {
		return &v
	}).(MySqlConnectionProfilePtrOutput)
}

// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
func (o MySqlConnectionProfileOutput) CloudSqlId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) *string { return v.CloudSqlId }).(pulumi.StringPtrOutput)
}

// The IP or hostname of the source MySQL database.
func (o MySqlConnectionProfileOutput) Host() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) string { return v.Host }).(pulumi.StringOutput)
}

// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfileOutput) Password() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) string { return v.Password }).(pulumi.StringOutput)
}

// The network port of the source MySQL database.
func (o MySqlConnectionProfileOutput) Port() pulumi.IntOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) int { return v.Port }).(pulumi.IntOutput)
}

// SSL configuration for the destination to connect to the source database.
func (o MySqlConnectionProfileOutput) Ssl() SslConfigPtrOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) *SslConfig { return v.Ssl }).(SslConfigPtrOutput)
}

// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfileOutput) Username() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfile) string { return v.Username }).(pulumi.StringOutput)
}

type MySqlConnectionProfilePtrOutput struct{ *pulumi.OutputState }

func (MySqlConnectionProfilePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**MySqlConnectionProfile)(nil)).Elem()
}

func (o MySqlConnectionProfilePtrOutput) ToMySqlConnectionProfilePtrOutput() MySqlConnectionProfilePtrOutput {
	return o
}

func (o MySqlConnectionProfilePtrOutput) ToMySqlConnectionProfilePtrOutputWithContext(ctx context.Context) MySqlConnectionProfilePtrOutput {
	return o
}

func (o MySqlConnectionProfilePtrOutput) Elem() MySqlConnectionProfileOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) MySqlConnectionProfile {
		if v != nil {
			return *v
		}
		var ret MySqlConnectionProfile
		return ret
	}).(MySqlConnectionProfileOutput)
}

// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
func (o MySqlConnectionProfilePtrOutput) CloudSqlId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *string {
		if v == nil {
			return nil
		}
		return v.CloudSqlId
	}).(pulumi.StringPtrOutput)
}

// The IP or hostname of the source MySQL database.
func (o MySqlConnectionProfilePtrOutput) Host() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *string {
		if v == nil {
			return nil
		}
		return &v.Host
	}).(pulumi.StringPtrOutput)
}

// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfilePtrOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *string {
		if v == nil {
			return nil
		}
		return &v.Password
	}).(pulumi.StringPtrOutput)
}

// The network port of the source MySQL database.
func (o MySqlConnectionProfilePtrOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *int {
		if v == nil {
			return nil
		}
		return &v.Port
	}).(pulumi.IntPtrOutput)
}

// SSL configuration for the destination to connect to the source database.
func (o MySqlConnectionProfilePtrOutput) Ssl() SslConfigPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *SslConfig {
		if v == nil {
			return nil
		}
		return v.Ssl
	}).(SslConfigPtrOutput)
}

// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfilePtrOutput) Username() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *MySqlConnectionProfile) *string {
		if v == nil {
			return nil
		}
		return &v.Username
	}).(pulumi.StringPtrOutput)
}

// Specifies connection parameters required specifically for MySQL databases.
type MySqlConnectionProfileResponse struct {
	// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
	CloudSqlId string `pulumi:"cloudSqlId"`
	// The IP or hostname of the source MySQL database.
	Host string `pulumi:"host"`
	// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
	Password string `pulumi:"password"`
	// Indicates If this connection profile password is stored.
	PasswordSet bool `pulumi:"passwordSet"`
	// The network port of the source MySQL database.
	Port int `pulumi:"port"`
	// SSL configuration for the destination to connect to the source database.
	Ssl SslConfigResponse `pulumi:"ssl"`
	// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
	Username string `pulumi:"username"`
}

// Specifies connection parameters required specifically for MySQL databases.
type MySqlConnectionProfileResponseOutput struct{ *pulumi.OutputState }

func (MySqlConnectionProfileResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*MySqlConnectionProfileResponse)(nil)).Elem()
}

func (o MySqlConnectionProfileResponseOutput) ToMySqlConnectionProfileResponseOutput() MySqlConnectionProfileResponseOutput {
	return o
}

func (o MySqlConnectionProfileResponseOutput) ToMySqlConnectionProfileResponseOutputWithContext(ctx context.Context) MySqlConnectionProfileResponseOutput {
	return o
}

// If the source is a Cloud SQL database, use this field to provide the Cloud SQL instance ID of the source.
func (o MySqlConnectionProfileResponseOutput) CloudSqlId() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) string { return v.CloudSqlId }).(pulumi.StringOutput)
}

// The IP or hostname of the source MySQL database.
func (o MySqlConnectionProfileResponseOutput) Host() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) string { return v.Host }).(pulumi.StringOutput)
}

// Input only. The password for the user that Database Migration Service will be using to connect to the database. This field is not returned on request, and the value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfileResponseOutput) Password() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) string { return v.Password }).(pulumi.StringOutput)
}

// Indicates If this connection profile password is stored.
func (o MySqlConnectionProfileResponseOutput) PasswordSet() pulumi.BoolOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) bool { return v.PasswordSet }).(pulumi.BoolOutput)
}

// The network port of the source MySQL database.
func (o MySqlConnectionProfileResponseOutput) Port() pulumi.IntOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) int { return v.Port }).(pulumi.IntOutput)
}

// SSL configuration for the destination to connect to the source database.
func (o MySqlConnectionProfileResponseOutput) Ssl() SslConfigResponseOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) SslConfigResponse { return v.Ssl }).(SslConfigResponseOutput)
}

// The username that Database Migration Service will use to connect to the database. The value is encrypted when stored in Database Migration Service.
func (o MySqlConnectionProfileResponseOutput) Username() pulumi.StringOutput {
	return o.ApplyT(func(v MySqlConnectionProfileResponse) string { return v.Username }).(pulumi.StringOutput)
}

// The details needed to configure a reverse SSH tunnel between the source and destination databases. These details will be used when calling the generateSshScript method (see https://cloud.google.com/database-migration/docs/reference/rest/v1beta1/projects.locations.migrationJobs/generateSshScript) to produce the script that will help set up the reverse SSH tunnel, and to set up the VPC peering between the Cloud SQL private network and the VPC.
type ReverseSshConnectivity struct {
	// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	Vm *string `pulumi:"vm"`
	// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmIp string `pulumi:"vmIp"`
	// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmPort int `pulumi:"vmPort"`
	// The name of the VPC to peer with the Cloud SQL private network.
	Vpc *string `pulumi:"vpc"`
}

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

	ToReverseSshConnectivityOutput() ReverseSshConnectivityOutput
	ToReverseSshConnectivityOutputWithContext(context.Context) ReverseSshConnectivityOutput
}

// The details needed to configure a reverse SSH tunnel between the source and destination databases. These details will be used when calling the generateSshScript method (see https://cloud.google.com/database-migration/docs/reference/rest/v1beta1/projects.locations.migrationJobs/generateSshScript) to produce the script that will help set up the reverse SSH tunnel, and to set up the VPC peering between the Cloud SQL private network and the VPC.
type ReverseSshConnectivityArgs struct {
	// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	Vm pulumi.StringPtrInput `pulumi:"vm"`
	// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmIp pulumi.StringInput `pulumi:"vmIp"`
	// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmPort pulumi.IntInput `pulumi:"vmPort"`
	// The name of the VPC to peer with the Cloud SQL private network.
	Vpc pulumi.StringPtrInput `pulumi:"vpc"`
}

func (ReverseSshConnectivityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ReverseSshConnectivity)(nil)).Elem()
}

func (i ReverseSshConnectivityArgs) ToReverseSshConnectivityOutput() ReverseSshConnectivityOutput {
	return i.ToReverseSshConnectivityOutputWithContext(context.Background())
}

func (i ReverseSshConnectivityArgs) ToReverseSshConnectivityOutputWithContext(ctx context.Context) ReverseSshConnectivityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReverseSshConnectivityOutput)
}

func (i ReverseSshConnectivityArgs) ToReverseSshConnectivityPtrOutput() ReverseSshConnectivityPtrOutput {
	return i.ToReverseSshConnectivityPtrOutputWithContext(context.Background())
}

func (i ReverseSshConnectivityArgs) ToReverseSshConnectivityPtrOutputWithContext(ctx context.Context) ReverseSshConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReverseSshConnectivityOutput).ToReverseSshConnectivityPtrOutputWithContext(ctx)
}

// ReverseSshConnectivityPtrInput is an input type that accepts ReverseSshConnectivityArgs, ReverseSshConnectivityPtr and ReverseSshConnectivityPtrOutput values.
// You can construct a concrete instance of `ReverseSshConnectivityPtrInput` via:
//
//	        ReverseSshConnectivityArgs{...}
//
//	or:
//
//	        nil
type ReverseSshConnectivityPtrInput interface {
	pulumi.Input

	ToReverseSshConnectivityPtrOutput() ReverseSshConnectivityPtrOutput
	ToReverseSshConnectivityPtrOutputWithContext(context.Context) ReverseSshConnectivityPtrOutput
}

type reverseSshConnectivityPtrType ReverseSshConnectivityArgs

func ReverseSshConnectivityPtr(v *ReverseSshConnectivityArgs) ReverseSshConnectivityPtrInput {
	return (*reverseSshConnectivityPtrType)(v)
}

func (*reverseSshConnectivityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ReverseSshConnectivity)(nil)).Elem()
}

func (i *reverseSshConnectivityPtrType) ToReverseSshConnectivityPtrOutput() ReverseSshConnectivityPtrOutput {
	return i.ToReverseSshConnectivityPtrOutputWithContext(context.Background())
}

func (i *reverseSshConnectivityPtrType) ToReverseSshConnectivityPtrOutputWithContext(ctx context.Context) ReverseSshConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ReverseSshConnectivityPtrOutput)
}

// The details needed to configure a reverse SSH tunnel between the source and destination databases. These details will be used when calling the generateSshScript method (see https://cloud.google.com/database-migration/docs/reference/rest/v1beta1/projects.locations.migrationJobs/generateSshScript) to produce the script that will help set up the reverse SSH tunnel, and to set up the VPC peering between the Cloud SQL private network and the VPC.
type ReverseSshConnectivityOutput struct{ *pulumi.OutputState }

func (ReverseSshConnectivityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReverseSshConnectivity)(nil)).Elem()
}

func (o ReverseSshConnectivityOutput) ToReverseSshConnectivityOutput() ReverseSshConnectivityOutput {
	return o
}

func (o ReverseSshConnectivityOutput) ToReverseSshConnectivityOutputWithContext(ctx context.Context) ReverseSshConnectivityOutput {
	return o
}

func (o ReverseSshConnectivityOutput) ToReverseSshConnectivityPtrOutput() ReverseSshConnectivityPtrOutput {
	return o.ToReverseSshConnectivityPtrOutputWithContext(context.Background())
}

func (o ReverseSshConnectivityOutput) ToReverseSshConnectivityPtrOutputWithContext(ctx context.Context) ReverseSshConnectivityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ReverseSshConnectivity) *ReverseSshConnectivity {
		return &v
	}).(ReverseSshConnectivityPtrOutput)
}

// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityOutput) Vm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ReverseSshConnectivity) *string { return v.Vm }).(pulumi.StringPtrOutput)
}

// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityOutput) VmIp() pulumi.StringOutput {
	return o.ApplyT(func(v ReverseSshConnectivity) string { return v.VmIp }).(pulumi.StringOutput)
}

// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityOutput) VmPort() pulumi.IntOutput {
	return o.ApplyT(func(v ReverseSshConnectivity) int { return v.VmPort }).(pulumi.IntOutput)
}

// The name of the VPC to peer with the Cloud SQL private network.
func (o ReverseSshConnectivityOutput) Vpc() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ReverseSshConnectivity) *string { return v.Vpc }).(pulumi.StringPtrOutput)
}

type ReverseSshConnectivityPtrOutput struct{ *pulumi.OutputState }

func (ReverseSshConnectivityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ReverseSshConnectivity)(nil)).Elem()
}

func (o ReverseSshConnectivityPtrOutput) ToReverseSshConnectivityPtrOutput() ReverseSshConnectivityPtrOutput {
	return o
}

func (o ReverseSshConnectivityPtrOutput) ToReverseSshConnectivityPtrOutputWithContext(ctx context.Context) ReverseSshConnectivityPtrOutput {
	return o
}

func (o ReverseSshConnectivityPtrOutput) Elem() ReverseSshConnectivityOutput {
	return o.ApplyT(func(v *ReverseSshConnectivity) ReverseSshConnectivity {
		if v != nil {
			return *v
		}
		var ret ReverseSshConnectivity
		return ret
	}).(ReverseSshConnectivityOutput)
}

// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityPtrOutput) Vm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ReverseSshConnectivity) *string {
		if v == nil {
			return nil
		}
		return v.Vm
	}).(pulumi.StringPtrOutput)
}

// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityPtrOutput) VmIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ReverseSshConnectivity) *string {
		if v == nil {
			return nil
		}
		return &v.VmIp
	}).(pulumi.StringPtrOutput)
}

// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityPtrOutput) VmPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ReverseSshConnectivity) *int {
		if v == nil {
			return nil
		}
		return &v.VmPort
	}).(pulumi.IntPtrOutput)
}

// The name of the VPC to peer with the Cloud SQL private network.
func (o ReverseSshConnectivityPtrOutput) Vpc() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ReverseSshConnectivity) *string {
		if v == nil {
			return nil
		}
		return v.Vpc
	}).(pulumi.StringPtrOutput)
}

// The details needed to configure a reverse SSH tunnel between the source and destination databases. These details will be used when calling the generateSshScript method (see https://cloud.google.com/database-migration/docs/reference/rest/v1beta1/projects.locations.migrationJobs/generateSshScript) to produce the script that will help set up the reverse SSH tunnel, and to set up the VPC peering between the Cloud SQL private network and the VPC.
type ReverseSshConnectivityResponse struct {
	// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	Vm string `pulumi:"vm"`
	// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmIp string `pulumi:"vmIp"`
	// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
	VmPort int `pulumi:"vmPort"`
	// The name of the VPC to peer with the Cloud SQL private network.
	Vpc string `pulumi:"vpc"`
}

// The details needed to configure a reverse SSH tunnel between the source and destination databases. These details will be used when calling the generateSshScript method (see https://cloud.google.com/database-migration/docs/reference/rest/v1beta1/projects.locations.migrationJobs/generateSshScript) to produce the script that will help set up the reverse SSH tunnel, and to set up the VPC peering between the Cloud SQL private network and the VPC.
type ReverseSshConnectivityResponseOutput struct{ *pulumi.OutputState }

func (ReverseSshConnectivityResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReverseSshConnectivityResponse)(nil)).Elem()
}

func (o ReverseSshConnectivityResponseOutput) ToReverseSshConnectivityResponseOutput() ReverseSshConnectivityResponseOutput {
	return o
}

func (o ReverseSshConnectivityResponseOutput) ToReverseSshConnectivityResponseOutputWithContext(ctx context.Context) ReverseSshConnectivityResponseOutput {
	return o
}

// The name of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityResponseOutput) Vm() pulumi.StringOutput {
	return o.ApplyT(func(v ReverseSshConnectivityResponse) string { return v.Vm }).(pulumi.StringOutput)
}

// The IP of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityResponseOutput) VmIp() pulumi.StringOutput {
	return o.ApplyT(func(v ReverseSshConnectivityResponse) string { return v.VmIp }).(pulumi.StringOutput)
}

// The forwarding port of the virtual machine (Compute Engine) used as the bastion server for the SSH tunnel.
func (o ReverseSshConnectivityResponseOutput) VmPort() pulumi.IntOutput {
	return o.ApplyT(func(v ReverseSshConnectivityResponse) int { return v.VmPort }).(pulumi.IntOutput)
}

// The name of the VPC to peer with the Cloud SQL private network.
func (o ReverseSshConnectivityResponseOutput) Vpc() pulumi.StringOutput {
	return o.ApplyT(func(v ReverseSshConnectivityResponse) string { return v.Vpc }).(pulumi.StringOutput)
}

// An entry for an Access Control list.
type SqlAclEntry struct {
	// The time when this access control entry expires in [RFC 3339](https://tools.ietf.org/html/rfc3339) format, for example: `2012-11-15T16:19:00.094Z`.
	ExpireTime *string `pulumi:"expireTime"`
	// A label to identify this entry.
	Label *string `pulumi:"label"`
	// Input only. The time-to-leave of this access control entry.
	Ttl *string `pulumi:"ttl"`
	// The allowlisted value for the access control list.
	Value *string `pulumi:"value"`
}

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

	ToSqlAclEntryOutput() SqlAclEntryOutput
	ToSqlAclEntryOutputWithContext(context.Context) SqlAclEntryOutput
}

// An entry for an Access Control list.
type SqlAclEntryArgs struct {
	// The time when this access control entry expires in [RFC 3339](https://tools.ietf.org/html/rfc3339) format, for example: `2012-11-15T16:19:00.094Z`.
	ExpireTime pulumi.StringPtrInput `pulumi:"expireTime"`
	// A label to identify this entry.
	Label pulumi.StringPtrInput `pulumi:"label"`
	// Input only. The time-to-leave of this access control entry.
	Ttl pulumi.StringPtrInput `pulumi:"ttl"`
	// The allowlisted value for the access control list.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

func (SqlAclEntryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlAclEntry)(nil)).Elem()
}

func (i SqlAclEntryArgs) ToSqlAclEntryOutput() SqlAclEntryOutput {
	return i.ToSqlAclEntryOutputWithContext(context.Background())
}

func (i SqlAclEntryArgs) ToSqlAclEntryOutputWithContext(ctx context.Context) SqlAclEntryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SqlAclEntryOutput)
}

// SqlAclEntryArrayInput is an input type that accepts SqlAclEntryArray and SqlAclEntryArrayOutput values.
// You can construct a concrete instance of `SqlAclEntryArrayInput` via:
//
//	SqlAclEntryArray{ SqlAclEntryArgs{...} }
type SqlAclEntryArrayInput interface {
	pulumi.Input

	ToSqlAclEntryArrayOutput() SqlAclEntryArrayOutput
	ToSqlAclEntryArrayOutputWithContext(context.Context) SqlAclEntryArrayOutput
}

type SqlAclEntryArray []SqlAclEntryInput

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

func (i SqlAclEntryArray) ToSqlAclEntryArrayOutput() SqlAclEntryArrayOutput {
	return i.ToSqlAclEntryArrayOutputWithContext(context.Background())
}

func (i SqlAclEntryArray) ToSqlAclEntryArrayOutputWithContext(ctx context.Context) SqlAclEntryArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SqlAclEntryArrayOutput)
}

// An entry for an Access Control list.
type SqlAclEntryOutput struct{ *pulumi.OutputState }

func (SqlAclEntryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlAclEntry)(nil)).Elem()
}

func (o SqlAclEntryOutput) ToSqlAclEntryOutput() SqlAclEntryOutput {
	return o
}

func (o SqlAclEntryOutput) ToSqlAclEntryOutputWithContext(ctx context.Context) SqlAclEntryOutput {
	return o
}

// The time when this access control entry expires in [RFC 3339](https://tools.ietf.org/html/rfc3339) format, for example: `2012-11-15T16:19:00.094Z`.
func (o SqlAclEntryOutput) ExpireTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SqlAclEntry) *string { return v.ExpireTime }).(pulumi.StringPtrOutput)
}

// A label to identify this entry.
func (o SqlAclEntryOutput) Label() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SqlAclEntry) *string { return v.Label }).(pulumi.StringPtrOutput)
}

// Input only. The time-to-leave of this access control entry.
func (o SqlAclEntryOutput) Ttl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SqlAclEntry) *string { return v.Ttl }).(pulumi.StringPtrOutput)
}

// The allowlisted value for the access control list.
func (o SqlAclEntryOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SqlAclEntry) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type SqlAclEntryArrayOutput struct{ *pulumi.OutputState }

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

func (o SqlAclEntryArrayOutput) ToSqlAclEntryArrayOutput() SqlAclEntryArrayOutput {
	return o
}

func (o SqlAclEntryArrayOutput) ToSqlAclEntryArrayOutputWithContext(ctx context.Context) SqlAclEntryArrayOutput {
	return o
}

func (o SqlAclEntryArrayOutput) Index(i pulumi.IntInput) SqlAclEntryOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SqlAclEntry {
		return vs[0].([]SqlAclEntry)[vs[1].(int)]
	}).(SqlAclEntryOutput)
}

// An entry for an Access Control list.
type SqlAclEntryResponse struct {
	// The time when this access control entry expires in [RFC 3339](https://tools.ietf.org/html/rfc3339) format, for example: `2012-11-15T16:19:00.094Z`.
	ExpireTime string `pulumi:"expireTime"`
	// A label to identify this entry.
	Label string `pulumi:"label"`
	// Input only. The time-to-leave of this access control entry.
	Ttl string `pulumi:"ttl"`
	// The allowlisted value for the access control list.
	Value string `pulumi:"value"`
}

// An entry for an Access Control list.
type SqlAclEntryResponseOutput struct{ *pulumi.OutputState }

func (SqlAclEntryResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlAclEntryResponse)(nil)).Elem()
}

func (o SqlAclEntryResponseOutput) ToSqlAclEntryResponseOutput() SqlAclEntryResponseOutput {
	return o
}

func (o SqlAclEntryResponseOutput) ToSqlAclEntryResponseOutputWithContext(ctx context.Context) SqlAclEntryResponseOutput {
	return o
}

// The time when this access control entry expires in [RFC 3339](https://tools.ietf.org/html/rfc3339) format, for example: `2012-11-15T16:19:00.094Z`.
func (o SqlAclEntryResponseOutput) ExpireTime() pulumi.StringOutput {
	return o.ApplyT(func(v SqlAclEntryResponse) string { return v.ExpireTime }).(pulumi.StringOutput)
}

// A label to identify this entry.
func (o SqlAclEntryResponseOutput) Label() pulumi.StringOutput {
	return o.ApplyT(func(v SqlAclEntryResponse) string { return v.Label }).(pulumi.StringOutput)
}

// Input only. The time-to-leave of this access control entry.
func (o SqlAclEntryResponseOutput) Ttl() pulumi.StringOutput {
	return o.ApplyT(func(v SqlAclEntryResponse) string { return v.Ttl }).(pulumi.StringOutput)
}

// The allowlisted value for the access control list.
func (o SqlAclEntryResponseOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v SqlAclEntryResponse) string { return v.Value }).(pulumi.StringOutput)
}

type SqlAclEntryResponseArrayOutput struct{ *pulumi.OutputState }

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

func (o SqlAclEntryResponseArrayOutput) ToSqlAclEntryResponseArrayOutput() SqlAclEntryResponseArrayOutput {
	return o
}

func (o SqlAclEntryResponseArrayOutput) ToSqlAclEntryResponseArrayOutputWithContext(ctx context.Context) SqlAclEntryResponseArrayOutput {
	return o
}

func (o SqlAclEntryResponseArrayOutput) Index(i pulumi.IntInput) SqlAclEntryResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) SqlAclEntryResponse {
		return vs[0].([]SqlAclEntryResponse)[vs[1].(int)]
	}).(SqlAclEntryResponseOutput)
}

// IP Management configuration.
type SqlIpConfig struct {
	// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
	AuthorizedNetworks []SqlAclEntry `pulumi:"authorizedNetworks"`
	// Whether the instance is assigned a public IP address or not.
	EnableIpv4 *bool `pulumi:"enableIpv4"`
	// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
	PrivateNetwork *string `pulumi:"privateNetwork"`
	// Whether SSL connections over IP should be enforced or not.
	RequireSsl *bool `pulumi:"requireSsl"`
}

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

	ToSqlIpConfigOutput() SqlIpConfigOutput
	ToSqlIpConfigOutputWithContext(context.Context) SqlIpConfigOutput
}

// IP Management configuration.
type SqlIpConfigArgs struct {
	// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
	AuthorizedNetworks SqlAclEntryArrayInput `pulumi:"authorizedNetworks"`
	// Whether the instance is assigned a public IP address or not.
	EnableIpv4 pulumi.BoolPtrInput `pulumi:"enableIpv4"`
	// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
	PrivateNetwork pulumi.StringPtrInput `pulumi:"privateNetwork"`
	// Whether SSL connections over IP should be enforced or not.
	RequireSsl pulumi.BoolPtrInput `pulumi:"requireSsl"`
}

func (SqlIpConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlIpConfig)(nil)).Elem()
}

func (i SqlIpConfigArgs) ToSqlIpConfigOutput() SqlIpConfigOutput {
	return i.ToSqlIpConfigOutputWithContext(context.Background())
}

func (i SqlIpConfigArgs) ToSqlIpConfigOutputWithContext(ctx context.Context) SqlIpConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SqlIpConfigOutput)
}

func (i SqlIpConfigArgs) ToSqlIpConfigPtrOutput() SqlIpConfigPtrOutput {
	return i.ToSqlIpConfigPtrOutputWithContext(context.Background())
}

func (i SqlIpConfigArgs) ToSqlIpConfigPtrOutputWithContext(ctx context.Context) SqlIpConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SqlIpConfigOutput).ToSqlIpConfigPtrOutputWithContext(ctx)
}

// SqlIpConfigPtrInput is an input type that accepts SqlIpConfigArgs, SqlIpConfigPtr and SqlIpConfigPtrOutput values.
// You can construct a concrete instance of `SqlIpConfigPtrInput` via:
//
//	        SqlIpConfigArgs{...}
//
//	or:
//
//	        nil
type SqlIpConfigPtrInput interface {
	pulumi.Input

	ToSqlIpConfigPtrOutput() SqlIpConfigPtrOutput
	ToSqlIpConfigPtrOutputWithContext(context.Context) SqlIpConfigPtrOutput
}

type sqlIpConfigPtrType SqlIpConfigArgs

func SqlIpConfigPtr(v *SqlIpConfigArgs) SqlIpConfigPtrInput {
	return (*sqlIpConfigPtrType)(v)
}

func (*sqlIpConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**SqlIpConfig)(nil)).Elem()
}

func (i *sqlIpConfigPtrType) ToSqlIpConfigPtrOutput() SqlIpConfigPtrOutput {
	return i.ToSqlIpConfigPtrOutputWithContext(context.Background())
}

func (i *sqlIpConfigPtrType) ToSqlIpConfigPtrOutputWithContext(ctx context.Context) SqlIpConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SqlIpConfigPtrOutput)
}

// IP Management configuration.
type SqlIpConfigOutput struct{ *pulumi.OutputState }

func (SqlIpConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlIpConfig)(nil)).Elem()
}

func (o SqlIpConfigOutput) ToSqlIpConfigOutput() SqlIpConfigOutput {
	return o
}

func (o SqlIpConfigOutput) ToSqlIpConfigOutputWithContext(ctx context.Context) SqlIpConfigOutput {
	return o
}

func (o SqlIpConfigOutput) ToSqlIpConfigPtrOutput() SqlIpConfigPtrOutput {
	return o.ToSqlIpConfigPtrOutputWithContext(context.Background())
}

func (o SqlIpConfigOutput) ToSqlIpConfigPtrOutputWithContext(ctx context.Context) SqlIpConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SqlIpConfig) *SqlIpConfig {
		return &v
	}).(SqlIpConfigPtrOutput)
}

// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
func (o SqlIpConfigOutput) AuthorizedNetworks() SqlAclEntryArrayOutput {
	return o.ApplyT(func(v SqlIpConfig) []SqlAclEntry { return v.AuthorizedNetworks }).(SqlAclEntryArrayOutput)
}

// Whether the instance is assigned a public IP address or not.
func (o SqlIpConfigOutput) EnableIpv4() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v SqlIpConfig) *bool { return v.EnableIpv4 }).(pulumi.BoolPtrOutput)
}

// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
func (o SqlIpConfigOutput) PrivateNetwork() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SqlIpConfig) *string { return v.PrivateNetwork }).(pulumi.StringPtrOutput)
}

// Whether SSL connections over IP should be enforced or not.
func (o SqlIpConfigOutput) RequireSsl() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v SqlIpConfig) *bool { return v.RequireSsl }).(pulumi.BoolPtrOutput)
}

type SqlIpConfigPtrOutput struct{ *pulumi.OutputState }

func (SqlIpConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SqlIpConfig)(nil)).Elem()
}

func (o SqlIpConfigPtrOutput) ToSqlIpConfigPtrOutput() SqlIpConfigPtrOutput {
	return o
}

func (o SqlIpConfigPtrOutput) ToSqlIpConfigPtrOutputWithContext(ctx context.Context) SqlIpConfigPtrOutput {
	return o
}

func (o SqlIpConfigPtrOutput) Elem() SqlIpConfigOutput {
	return o.ApplyT(func(v *SqlIpConfig) SqlIpConfig {
		if v != nil {
			return *v
		}
		var ret SqlIpConfig
		return ret
	}).(SqlIpConfigOutput)
}

// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
func (o SqlIpConfigPtrOutput) AuthorizedNetworks() SqlAclEntryArrayOutput {
	return o.ApplyT(func(v *SqlIpConfig) []SqlAclEntry {
		if v == nil {
			return nil
		}
		return v.AuthorizedNetworks
	}).(SqlAclEntryArrayOutput)
}

// Whether the instance is assigned a public IP address or not.
func (o SqlIpConfigPtrOutput) EnableIpv4() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *SqlIpConfig) *bool {
		if v == nil {
			return nil
		}
		return v.EnableIpv4
	}).(pulumi.BoolPtrOutput)
}

// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
func (o SqlIpConfigPtrOutput) PrivateNetwork() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SqlIpConfig) *string {
		if v == nil {
			return nil
		}
		return v.PrivateNetwork
	}).(pulumi.StringPtrOutput)
}

// Whether SSL connections over IP should be enforced or not.
func (o SqlIpConfigPtrOutput) RequireSsl() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *SqlIpConfig) *bool {
		if v == nil {
			return nil
		}
		return v.RequireSsl
	}).(pulumi.BoolPtrOutput)
}

// IP Management configuration.
type SqlIpConfigResponse struct {
	// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
	AuthorizedNetworks []SqlAclEntryResponse `pulumi:"authorizedNetworks"`
	// Whether the instance is assigned a public IP address or not.
	EnableIpv4 bool `pulumi:"enableIpv4"`
	// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
	PrivateNetwork string `pulumi:"privateNetwork"`
	// Whether SSL connections over IP should be enforced or not.
	RequireSsl bool `pulumi:"requireSsl"`
}

// IP Management configuration.
type SqlIpConfigResponseOutput struct{ *pulumi.OutputState }

func (SqlIpConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SqlIpConfigResponse)(nil)).Elem()
}

func (o SqlIpConfigResponseOutput) ToSqlIpConfigResponseOutput() SqlIpConfigResponseOutput {
	return o
}

func (o SqlIpConfigResponseOutput) ToSqlIpConfigResponseOutputWithContext(ctx context.Context) SqlIpConfigResponseOutput {
	return o
}

// The list of external networks that are allowed to connect to the instance using the IP. See https://en.wikipedia.org/wiki/CIDR_notation#CIDR_notation, also known as 'slash' notation (e.g. `192.168.100.0/24`).
func (o SqlIpConfigResponseOutput) AuthorizedNetworks() SqlAclEntryResponseArrayOutput {
	return o.ApplyT(func(v SqlIpConfigResponse) []SqlAclEntryResponse { return v.AuthorizedNetworks }).(SqlAclEntryResponseArrayOutput)
}

// Whether the instance is assigned a public IP address or not.
func (o SqlIpConfigResponseOutput) EnableIpv4() pulumi.BoolOutput {
	return o.ApplyT(func(v SqlIpConfigResponse) bool { return v.EnableIpv4 }).(pulumi.BoolOutput)
}

// The resource link for the VPC network from which the Cloud SQL instance is accessible for private IP. For example, `/projects/myProject/global/networks/default`. This setting can be updated, but it cannot be removed after it is set.
func (o SqlIpConfigResponseOutput) PrivateNetwork() pulumi.StringOutput {
	return o.ApplyT(func(v SqlIpConfigResponse) string { return v.PrivateNetwork }).(pulumi.StringOutput)
}

// Whether SSL connections over IP should be enforced or not.
func (o SqlIpConfigResponseOutput) RequireSsl() pulumi.BoolOutput {
	return o.ApplyT(func(v SqlIpConfigResponse) bool { return v.RequireSsl }).(pulumi.BoolOutput)
}

// SSL configuration information.
type SslConfig struct {
	// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
	CaCertificate string `pulumi:"caCertificate"`
	// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
	ClientCertificate *string `pulumi:"clientCertificate"`
	// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
	ClientKey *string `pulumi:"clientKey"`
}

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

	ToSslConfigOutput() SslConfigOutput
	ToSslConfigOutputWithContext(context.Context) SslConfigOutput
}

// SSL configuration information.
type SslConfigArgs struct {
	// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
	CaCertificate pulumi.StringInput `pulumi:"caCertificate"`
	// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
	ClientCertificate pulumi.StringPtrInput `pulumi:"clientCertificate"`
	// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
	ClientKey pulumi.StringPtrInput `pulumi:"clientKey"`
}

func (SslConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SslConfig)(nil)).Elem()
}

func (i SslConfigArgs) ToSslConfigOutput() SslConfigOutput {
	return i.ToSslConfigOutputWithContext(context.Background())
}

func (i SslConfigArgs) ToSslConfigOutputWithContext(ctx context.Context) SslConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SslConfigOutput)
}

func (i SslConfigArgs) ToSslConfigPtrOutput() SslConfigPtrOutput {
	return i.ToSslConfigPtrOutputWithContext(context.Background())
}

func (i SslConfigArgs) ToSslConfigPtrOutputWithContext(ctx context.Context) SslConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SslConfigOutput).ToSslConfigPtrOutputWithContext(ctx)
}

// SslConfigPtrInput is an input type that accepts SslConfigArgs, SslConfigPtr and SslConfigPtrOutput values.
// You can construct a concrete instance of `SslConfigPtrInput` via:
//
//	        SslConfigArgs{...}
//
//	or:
//
//	        nil
type SslConfigPtrInput interface {
	pulumi.Input

	ToSslConfigPtrOutput() SslConfigPtrOutput
	ToSslConfigPtrOutputWithContext(context.Context) SslConfigPtrOutput
}

type sslConfigPtrType SslConfigArgs

func SslConfigPtr(v *SslConfigArgs) SslConfigPtrInput {
	return (*sslConfigPtrType)(v)
}

func (*sslConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**SslConfig)(nil)).Elem()
}

func (i *sslConfigPtrType) ToSslConfigPtrOutput() SslConfigPtrOutput {
	return i.ToSslConfigPtrOutputWithContext(context.Background())
}

func (i *sslConfigPtrType) ToSslConfigPtrOutputWithContext(ctx context.Context) SslConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SslConfigPtrOutput)
}

// SSL configuration information.
type SslConfigOutput struct{ *pulumi.OutputState }

func (SslConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SslConfig)(nil)).Elem()
}

func (o SslConfigOutput) ToSslConfigOutput() SslConfigOutput {
	return o
}

func (o SslConfigOutput) ToSslConfigOutputWithContext(ctx context.Context) SslConfigOutput {
	return o
}

func (o SslConfigOutput) ToSslConfigPtrOutput() SslConfigPtrOutput {
	return o.ToSslConfigPtrOutputWithContext(context.Background())
}

func (o SslConfigOutput) ToSslConfigPtrOutputWithContext(ctx context.Context) SslConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SslConfig) *SslConfig {
		return &v
	}).(SslConfigPtrOutput)
}

// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
func (o SslConfigOutput) CaCertificate() pulumi.StringOutput {
	return o.ApplyT(func(v SslConfig) string { return v.CaCertificate }).(pulumi.StringOutput)
}

// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
func (o SslConfigOutput) ClientCertificate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SslConfig) *string { return v.ClientCertificate }).(pulumi.StringPtrOutput)
}

// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
func (o SslConfigOutput) ClientKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SslConfig) *string { return v.ClientKey }).(pulumi.StringPtrOutput)
}

type SslConfigPtrOutput struct{ *pulumi.OutputState }

func (SslConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SslConfig)(nil)).Elem()
}

func (o SslConfigPtrOutput) ToSslConfigPtrOutput() SslConfigPtrOutput {
	return o
}

func (o SslConfigPtrOutput) ToSslConfigPtrOutputWithContext(ctx context.Context) SslConfigPtrOutput {
	return o
}

func (o SslConfigPtrOutput) Elem() SslConfigOutput {
	return o.ApplyT(func(v *SslConfig) SslConfig {
		if v != nil {
			return *v
		}
		var ret SslConfig
		return ret
	}).(SslConfigOutput)
}

// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
func (o SslConfigPtrOutput) CaCertificate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SslConfig) *string {
		if v == nil {
			return nil
		}
		return &v.CaCertificate
	}).(pulumi.StringPtrOutput)
}

// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
func (o SslConfigPtrOutput) ClientCertificate() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SslConfig) *string {
		if v == nil {
			return nil
		}
		return v.ClientCertificate
	}).(pulumi.StringPtrOutput)
}

// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
func (o SslConfigPtrOutput) ClientKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SslConfig) *string {
		if v == nil {
			return nil
		}
		return v.ClientKey
	}).(pulumi.StringPtrOutput)
}

// SSL configuration information.
type SslConfigResponse struct {
	// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
	CaCertificate string `pulumi:"caCertificate"`
	// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
	ClientCertificate string `pulumi:"clientCertificate"`
	// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
	ClientKey string `pulumi:"clientKey"`
	// The ssl config type according to 'client_key', 'client_certificate' and 'ca_certificate'.
	Type string `pulumi:"type"`
}

// SSL configuration information.
type SslConfigResponseOutput struct{ *pulumi.OutputState }

func (SslConfigResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SslConfigResponse)(nil)).Elem()
}

func (o SslConfigResponseOutput) ToSslConfigResponseOutput() SslConfigResponseOutput {
	return o
}

func (o SslConfigResponseOutput) ToSslConfigResponseOutputWithContext(ctx context.Context) SslConfigResponseOutput {
	return o
}

// Input only. The x509 PEM-encoded certificate of the CA that signed the source database server's certificate. The replica will use this certificate to verify it's connecting to the right host.
func (o SslConfigResponseOutput) CaCertificate() pulumi.StringOutput {
	return o.ApplyT(func(v SslConfigResponse) string { return v.CaCertificate }).(pulumi.StringOutput)
}

// Input only. The x509 PEM-encoded certificate that will be used by the replica to authenticate against the source database server.If this field is used then the 'client_key' field is mandatory.
func (o SslConfigResponseOutput) ClientCertificate() pulumi.StringOutput {
	return o.ApplyT(func(v SslConfigResponse) string { return v.ClientCertificate }).(pulumi.StringOutput)
}

// Input only. The unencrypted PKCS#1 or PKCS#8 PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' field is mandatory.
func (o SslConfigResponseOutput) ClientKey() pulumi.StringOutput {
	return o.ApplyT(func(v SslConfigResponse) string { return v.ClientKey }).(pulumi.StringOutput)
}

// The ssl config type according to 'client_key', 'client_certificate' and 'ca_certificate'.
func (o SslConfigResponseOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v SslConfigResponse) string { return v.Type }).(pulumi.StringOutput)
}

// The source database will allow incoming connections from the destination database's public IP. You can retrieve the Cloud SQL instance's public IP from the Cloud SQL console or using Cloud SQL APIs. No additional configuration is required.
type StaticIpConnectivity struct {
}

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

	ToStaticIpConnectivityOutput() StaticIpConnectivityOutput
	ToStaticIpConnectivityOutputWithContext(context.Context) StaticIpConnectivityOutput
}

// The source database will allow incoming connections from the destination database's public IP. You can retrieve the Cloud SQL instance's public IP from the Cloud SQL console or using Cloud SQL APIs. No additional configuration is required.
type StaticIpConnectivityArgs struct {
}

func (StaticIpConnectivityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*StaticIpConnectivity)(nil)).Elem()
}

func (i StaticIpConnectivityArgs) ToStaticIpConnectivityOutput() StaticIpConnectivityOutput {
	return i.ToStaticIpConnectivityOutputWithContext(context.Background())
}

func (i StaticIpConnectivityArgs) ToStaticIpConnectivityOutputWithContext(ctx context.Context) StaticIpConnectivityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StaticIpConnectivityOutput)
}

func (i StaticIpConnectivityArgs) ToStaticIpConnectivityPtrOutput() StaticIpConnectivityPtrOutput {
	return i.ToStaticIpConnectivityPtrOutputWithContext(context.Background())
}

func (i StaticIpConnectivityArgs) ToStaticIpConnectivityPtrOutputWithContext(ctx context.Context) StaticIpConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StaticIpConnectivityOutput).ToStaticIpConnectivityPtrOutputWithContext(ctx)
}

// StaticIpConnectivityPtrInput is an input type that accepts StaticIpConnectivityArgs, StaticIpConnectivityPtr and StaticIpConnectivityPtrOutput values.
// You can construct a concrete instance of `StaticIpConnectivityPtrInput` via:
//
//	        StaticIpConnectivityArgs{...}
//
//	or:
//
//	        nil
type StaticIpConnectivityPtrInput interface {
	pulumi.Input

	ToStaticIpConnectivityPtrOutput() StaticIpConnectivityPtrOutput
	ToStaticIpConnectivityPtrOutputWithContext(context.Context) StaticIpConnectivityPtrOutput
}

type staticIpConnectivityPtrType StaticIpConnectivityArgs

func StaticIpConnectivityPtr(v *StaticIpConnectivityArgs) StaticIpConnectivityPtrInput {
	return (*staticIpConnectivityPtrType)(v)
}

func (*staticIpConnectivityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**StaticIpConnectivity)(nil)).Elem()
}

func (i *staticIpConnectivityPtrType) ToStaticIpConnectivityPtrOutput() StaticIpConnectivityPtrOutput {
	return i.ToStaticIpConnectivityPtrOutputWithContext(context.Background())
}

func (i *staticIpConnectivityPtrType) ToStaticIpConnectivityPtrOutputWithContext(ctx context.Context) StaticIpConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(StaticIpConnectivityPtrOutput)
}

// The source database will allow incoming connections from the destination database's public IP. You can retrieve the Cloud SQL instance's public IP from the Cloud SQL console or using Cloud SQL APIs. No additional configuration is required.
type StaticIpConnectivityOutput struct{ *pulumi.OutputState }

func (StaticIpConnectivityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*StaticIpConnectivity)(nil)).Elem()
}

func (o StaticIpConnectivityOutput) ToStaticIpConnectivityOutput() StaticIpConnectivityOutput {
	return o
}

func (o StaticIpConnectivityOutput) ToStaticIpConnectivityOutputWithContext(ctx context.Context) StaticIpConnectivityOutput {
	return o
}

func (o StaticIpConnectivityOutput) ToStaticIpConnectivityPtrOutput() StaticIpConnectivityPtrOutput {
	return o.ToStaticIpConnectivityPtrOutputWithContext(context.Background())
}

func (o StaticIpConnectivityOutput) ToStaticIpConnectivityPtrOutputWithContext(ctx context.Context) StaticIpConnectivityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v StaticIpConnectivity) *StaticIpConnectivity {
		return &v
	}).(StaticIpConnectivityPtrOutput)
}

type StaticIpConnectivityPtrOutput struct{ *pulumi.OutputState }

func (StaticIpConnectivityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**StaticIpConnectivity)(nil)).Elem()
}

func (o StaticIpConnectivityPtrOutput) ToStaticIpConnectivityPtrOutput() StaticIpConnectivityPtrOutput {
	return o
}

func (o StaticIpConnectivityPtrOutput) ToStaticIpConnectivityPtrOutputWithContext(ctx context.Context) StaticIpConnectivityPtrOutput {
	return o
}

func (o StaticIpConnectivityPtrOutput) Elem() StaticIpConnectivityOutput {
	return o.ApplyT(func(v *StaticIpConnectivity) StaticIpConnectivity {
		if v != nil {
			return *v
		}
		var ret StaticIpConnectivity
		return ret
	}).(StaticIpConnectivityOutput)
}

// The source database will allow incoming connections from the destination database's public IP. You can retrieve the Cloud SQL instance's public IP from the Cloud SQL console or using Cloud SQL APIs. No additional configuration is required.
type StaticIpConnectivityResponse struct {
}

// The source database will allow incoming connections from the destination database's public IP. You can retrieve the Cloud SQL instance's public IP from the Cloud SQL console or using Cloud SQL APIs. No additional configuration is required.
type StaticIpConnectivityResponseOutput struct{ *pulumi.OutputState }

func (StaticIpConnectivityResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*StaticIpConnectivityResponse)(nil)).Elem()
}

func (o StaticIpConnectivityResponseOutput) ToStaticIpConnectivityResponseOutput() StaticIpConnectivityResponseOutput {
	return o
}

func (o StaticIpConnectivityResponseOutput) ToStaticIpConnectivityResponseOutputWithContext(ctx context.Context) StaticIpConnectivityResponseOutput {
	return o
}

// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
type StatusResponse struct {
	// The status code, which should be an enum value of google.rpc.Code.
	Code int `pulumi:"code"`
	// A list of messages that carry the error details. There is a common set of message types for APIs to use.
	Details []map[string]string `pulumi:"details"`
	// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
	Message string `pulumi:"message"`
}

// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
type StatusResponseOutput struct{ *pulumi.OutputState }

func (StatusResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*StatusResponse)(nil)).Elem()
}

func (o StatusResponseOutput) ToStatusResponseOutput() StatusResponseOutput {
	return o
}

func (o StatusResponseOutput) ToStatusResponseOutputWithContext(ctx context.Context) StatusResponseOutput {
	return o
}

// The status code, which should be an enum value of google.rpc.Code.
func (o StatusResponseOutput) Code() pulumi.IntOutput {
	return o.ApplyT(func(v StatusResponse) int { return v.Code }).(pulumi.IntOutput)
}

// A list of messages that carry the error details. There is a common set of message types for APIs to use.
func (o StatusResponseOutput) Details() pulumi.StringMapArrayOutput {
	return o.ApplyT(func(v StatusResponse) []map[string]string { return v.Details }).(pulumi.StringMapArrayOutput)
}

// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
func (o StatusResponseOutput) Message() pulumi.StringOutput {
	return o.ApplyT(func(v StatusResponse) string { return v.Message }).(pulumi.StringOutput)
}

// The details of the VPC where the source database is located in Google Cloud. We will use this information to set up the VPC peering connection between Cloud SQL and this VPC.
type VpcPeeringConnectivity struct {
	// The name of the VPC network to peer with the Cloud SQL private network.
	Vpc *string `pulumi:"vpc"`
}

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

	ToVpcPeeringConnectivityOutput() VpcPeeringConnectivityOutput
	ToVpcPeeringConnectivityOutputWithContext(context.Context) VpcPeeringConnectivityOutput
}

// The details of the VPC where the source database is located in Google Cloud. We will use this information to set up the VPC peering connection between Cloud SQL and this VPC.
type VpcPeeringConnectivityArgs struct {
	// The name of the VPC network to peer with the Cloud SQL private network.
	Vpc pulumi.StringPtrInput `pulumi:"vpc"`
}

func (VpcPeeringConnectivityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*VpcPeeringConnectivity)(nil)).Elem()
}

func (i VpcPeeringConnectivityArgs) ToVpcPeeringConnectivityOutput() VpcPeeringConnectivityOutput {
	return i.ToVpcPeeringConnectivityOutputWithContext(context.Background())
}

func (i VpcPeeringConnectivityArgs) ToVpcPeeringConnectivityOutputWithContext(ctx context.Context) VpcPeeringConnectivityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectivityOutput)
}

func (i VpcPeeringConnectivityArgs) ToVpcPeeringConnectivityPtrOutput() VpcPeeringConnectivityPtrOutput {
	return i.ToVpcPeeringConnectivityPtrOutputWithContext(context.Background())
}

func (i VpcPeeringConnectivityArgs) ToVpcPeeringConnectivityPtrOutputWithContext(ctx context.Context) VpcPeeringConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectivityOutput).ToVpcPeeringConnectivityPtrOutputWithContext(ctx)
}

// VpcPeeringConnectivityPtrInput is an input type that accepts VpcPeeringConnectivityArgs, VpcPeeringConnectivityPtr and VpcPeeringConnectivityPtrOutput values.
// You can construct a concrete instance of `VpcPeeringConnectivityPtrInput` via:
//
//	        VpcPeeringConnectivityArgs{...}
//
//	or:
//
//	        nil
type VpcPeeringConnectivityPtrInput interface {
	pulumi.Input

	ToVpcPeeringConnectivityPtrOutput() VpcPeeringConnectivityPtrOutput
	ToVpcPeeringConnectivityPtrOutputWithContext(context.Context) VpcPeeringConnectivityPtrOutput
}

type vpcPeeringConnectivityPtrType VpcPeeringConnectivityArgs

func VpcPeeringConnectivityPtr(v *VpcPeeringConnectivityArgs) VpcPeeringConnectivityPtrInput {
	return (*vpcPeeringConnectivityPtrType)(v)
}

func (*vpcPeeringConnectivityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**VpcPeeringConnectivity)(nil)).Elem()
}

func (i *vpcPeeringConnectivityPtrType) ToVpcPeeringConnectivityPtrOutput() VpcPeeringConnectivityPtrOutput {
	return i.ToVpcPeeringConnectivityPtrOutputWithContext(context.Background())
}

func (i *vpcPeeringConnectivityPtrType) ToVpcPeeringConnectivityPtrOutputWithContext(ctx context.Context) VpcPeeringConnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectivityPtrOutput)
}

// The details of the VPC where the source database is located in Google Cloud. We will use this information to set up the VPC peering connection between Cloud SQL and this VPC.
type VpcPeeringConnectivityOutput struct{ *pulumi.OutputState }

func (VpcPeeringConnectivityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*VpcPeeringConnectivity)(nil)).Elem()
}

func (o VpcPeeringConnectivityOutput) ToVpcPeeringConnectivityOutput() VpcPeeringConnectivityOutput {
	return o
}

func (o VpcPeeringConnectivityOutput) ToVpcPeeringConnectivityOutputWithContext(ctx context.Context) VpcPeeringConnectivityOutput {
	return o
}

func (o VpcPeeringConnectivityOutput) ToVpcPeeringConnectivityPtrOutput() VpcPeeringConnectivityPtrOutput {
	return o.ToVpcPeeringConnectivityPtrOutputWithContext(context.Background())
}

func (o VpcPeeringConnectivityOutput) ToVpcPeeringConnectivityPtrOutputWithContext(ctx context.Context) VpcPeeringConnectivityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v VpcPeeringConnectivity) *VpcPeeringConnectivity {
		return &v
	}).(VpcPeeringConnectivityPtrOutput)
}

// The name of the VPC network to peer with the Cloud SQL private network.
func (o VpcPeeringConnectivityOutput) Vpc() pulumi.StringPtrOutput {
	return o.ApplyT(func(v VpcPeeringConnectivity) *string { return v.Vpc }).(pulumi.StringPtrOutput)
}

type VpcPeeringConnectivityPtrOutput struct{ *pulumi.OutputState }

func (VpcPeeringConnectivityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**VpcPeeringConnectivity)(nil)).Elem()
}

func (o VpcPeeringConnectivityPtrOutput) ToVpcPeeringConnectivityPtrOutput() VpcPeeringConnectivityPtrOutput {
	return o
}

func (o VpcPeeringConnectivityPtrOutput) ToVpcPeeringConnectivityPtrOutputWithContext(ctx context.Context) VpcPeeringConnectivityPtrOutput {
	return o
}

func (o VpcPeeringConnectivityPtrOutput) Elem() VpcPeeringConnectivityOutput {
	return o.ApplyT(func(v *VpcPeeringConnectivity) VpcPeeringConnectivity {
		if v != nil {
			return *v
		}
		var ret VpcPeeringConnectivity
		return ret
	}).(VpcPeeringConnectivityOutput)
}

// The name of the VPC network to peer with the Cloud SQL private network.
func (o VpcPeeringConnectivityPtrOutput) Vpc() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *VpcPeeringConnectivity) *string {
		if v == nil {
			return nil
		}
		return v.Vpc
	}).(pulumi.StringPtrOutput)
}

// The details of the VPC where the source database is located in Google Cloud. We will use this information to set up the VPC peering connection between Cloud SQL and this VPC.
type VpcPeeringConnectivityResponse struct {
	// The name of the VPC network to peer with the Cloud SQL private network.
	Vpc string `pulumi:"vpc"`
}

// The details of the VPC where the source database is located in Google Cloud. We will use this information to set up the VPC peering connection between Cloud SQL and this VPC.
type VpcPeeringConnectivityResponseOutput struct{ *pulumi.OutputState }

func (VpcPeeringConnectivityResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*VpcPeeringConnectivityResponse)(nil)).Elem()
}

func (o VpcPeeringConnectivityResponseOutput) ToVpcPeeringConnectivityResponseOutput() VpcPeeringConnectivityResponseOutput {
	return o
}

func (o VpcPeeringConnectivityResponseOutput) ToVpcPeeringConnectivityResponseOutputWithContext(ctx context.Context) VpcPeeringConnectivityResponseOutput {
	return o
}

// The name of the VPC network to peer with the Cloud SQL private network.
func (o VpcPeeringConnectivityResponseOutput) Vpc() pulumi.StringOutput {
	return o.ApplyT(func(v VpcPeeringConnectivityResponse) string { return v.Vpc }).(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((*CloudSqlConnectionProfileInput)(nil)).Elem(), CloudSqlConnectionProfileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*CloudSqlConnectionProfilePtrInput)(nil)).Elem(), CloudSqlConnectionProfileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*CloudSqlSettingsInput)(nil)).Elem(), CloudSqlSettingsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*CloudSqlSettingsPtrInput)(nil)).Elem(), CloudSqlSettingsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DatabaseTypeInput)(nil)).Elem(), DatabaseTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DatabaseTypePtrInput)(nil)).Elem(), DatabaseTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ExprInput)(nil)).Elem(), ExprArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ExprPtrInput)(nil)).Elem(), ExprArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*MySqlConnectionProfileInput)(nil)).Elem(), MySqlConnectionProfileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*MySqlConnectionProfilePtrInput)(nil)).Elem(), MySqlConnectionProfileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReverseSshConnectivityInput)(nil)).Elem(), ReverseSshConnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ReverseSshConnectivityPtrInput)(nil)).Elem(), ReverseSshConnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SqlAclEntryInput)(nil)).Elem(), SqlAclEntryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SqlAclEntryArrayInput)(nil)).Elem(), SqlAclEntryArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SqlIpConfigInput)(nil)).Elem(), SqlIpConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SqlIpConfigPtrInput)(nil)).Elem(), SqlIpConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SslConfigInput)(nil)).Elem(), SslConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SslConfigPtrInput)(nil)).Elem(), SslConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*StaticIpConnectivityInput)(nil)).Elem(), StaticIpConnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*StaticIpConnectivityPtrInput)(nil)).Elem(), StaticIpConnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*VpcPeeringConnectivityInput)(nil)).Elem(), VpcPeeringConnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*VpcPeeringConnectivityPtrInput)(nil)).Elem(), VpcPeeringConnectivityArgs{})
	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(CloudSqlConnectionProfileOutput{})
	pulumi.RegisterOutputType(CloudSqlConnectionProfilePtrOutput{})
	pulumi.RegisterOutputType(CloudSqlConnectionProfileResponseOutput{})
	pulumi.RegisterOutputType(CloudSqlSettingsOutput{})
	pulumi.RegisterOutputType(CloudSqlSettingsPtrOutput{})
	pulumi.RegisterOutputType(CloudSqlSettingsResponseOutput{})
	pulumi.RegisterOutputType(DatabaseTypeOutput{})
	pulumi.RegisterOutputType(DatabaseTypePtrOutput{})
	pulumi.RegisterOutputType(DatabaseTypeResponseOutput{})
	pulumi.RegisterOutputType(ExprOutput{})
	pulumi.RegisterOutputType(ExprPtrOutput{})
	pulumi.RegisterOutputType(ExprResponseOutput{})
	pulumi.RegisterOutputType(MySqlConnectionProfileOutput{})
	pulumi.RegisterOutputType(MySqlConnectionProfilePtrOutput{})
	pulumi.RegisterOutputType(MySqlConnectionProfileResponseOutput{})
	pulumi.RegisterOutputType(ReverseSshConnectivityOutput{})
	pulumi.RegisterOutputType(ReverseSshConnectivityPtrOutput{})
	pulumi.RegisterOutputType(ReverseSshConnectivityResponseOutput{})
	pulumi.RegisterOutputType(SqlAclEntryOutput{})
	pulumi.RegisterOutputType(SqlAclEntryArrayOutput{})
	pulumi.RegisterOutputType(SqlAclEntryResponseOutput{})
	pulumi.RegisterOutputType(SqlAclEntryResponseArrayOutput{})
	pulumi.RegisterOutputType(SqlIpConfigOutput{})
	pulumi.RegisterOutputType(SqlIpConfigPtrOutput{})
	pulumi.RegisterOutputType(SqlIpConfigResponseOutput{})
	pulumi.RegisterOutputType(SslConfigOutput{})
	pulumi.RegisterOutputType(SslConfigPtrOutput{})
	pulumi.RegisterOutputType(SslConfigResponseOutput{})
	pulumi.RegisterOutputType(StaticIpConnectivityOutput{})
	pulumi.RegisterOutputType(StaticIpConnectivityPtrOutput{})
	pulumi.RegisterOutputType(StaticIpConnectivityResponseOutput{})
	pulumi.RegisterOutputType(StatusResponseOutput{})
	pulumi.RegisterOutputType(VpcPeeringConnectivityOutput{})
	pulumi.RegisterOutputType(VpcPeeringConnectivityPtrOutput{})
	pulumi.RegisterOutputType(VpcPeeringConnectivityResponseOutput{})
}