pulumiTypes.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package dns

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

var _ = internal.GetEnvOrDefault

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

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

	ToDnsManagedZoneIamBindingConditionOutput() DnsManagedZoneIamBindingConditionOutput
	ToDnsManagedZoneIamBindingConditionOutputWithContext(context.Context) DnsManagedZoneIamBindingConditionOutput
}

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

func (DnsManagedZoneIamBindingConditionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DnsManagedZoneIamBindingCondition)(nil)).Elem()
}

func (i DnsManagedZoneIamBindingConditionArgs) ToDnsManagedZoneIamBindingConditionOutput() DnsManagedZoneIamBindingConditionOutput {
	return i.ToDnsManagedZoneIamBindingConditionOutputWithContext(context.Background())
}

func (i DnsManagedZoneIamBindingConditionArgs) ToDnsManagedZoneIamBindingConditionOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamBindingConditionOutput)
}

func (i DnsManagedZoneIamBindingConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DnsManagedZoneIamBindingCondition] {
	return pulumix.Output[DnsManagedZoneIamBindingCondition]{
		OutputState: i.ToDnsManagedZoneIamBindingConditionOutputWithContext(ctx).OutputState,
	}
}

func (i DnsManagedZoneIamBindingConditionArgs) ToDnsManagedZoneIamBindingConditionPtrOutput() DnsManagedZoneIamBindingConditionPtrOutput {
	return i.ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(context.Background())
}

func (i DnsManagedZoneIamBindingConditionArgs) ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamBindingConditionOutput).ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx)
}

// DnsManagedZoneIamBindingConditionPtrInput is an input type that accepts DnsManagedZoneIamBindingConditionArgs, DnsManagedZoneIamBindingConditionPtr and DnsManagedZoneIamBindingConditionPtrOutput values.
// You can construct a concrete instance of `DnsManagedZoneIamBindingConditionPtrInput` via:
//
//	        DnsManagedZoneIamBindingConditionArgs{...}
//
//	or:
//
//	        nil
type DnsManagedZoneIamBindingConditionPtrInput interface {
	pulumi.Input

	ToDnsManagedZoneIamBindingConditionPtrOutput() DnsManagedZoneIamBindingConditionPtrOutput
	ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(context.Context) DnsManagedZoneIamBindingConditionPtrOutput
}

type dnsManagedZoneIamBindingConditionPtrType DnsManagedZoneIamBindingConditionArgs

func DnsManagedZoneIamBindingConditionPtr(v *DnsManagedZoneIamBindingConditionArgs) DnsManagedZoneIamBindingConditionPtrInput {
	return (*dnsManagedZoneIamBindingConditionPtrType)(v)
}

func (*dnsManagedZoneIamBindingConditionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DnsManagedZoneIamBindingCondition)(nil)).Elem()
}

func (i *dnsManagedZoneIamBindingConditionPtrType) ToDnsManagedZoneIamBindingConditionPtrOutput() DnsManagedZoneIamBindingConditionPtrOutput {
	return i.ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(context.Background())
}

func (i *dnsManagedZoneIamBindingConditionPtrType) ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamBindingConditionPtrOutput)
}

func (i *dnsManagedZoneIamBindingConditionPtrType) ToOutput(ctx context.Context) pulumix.Output[*DnsManagedZoneIamBindingCondition] {
	return pulumix.Output[*DnsManagedZoneIamBindingCondition]{
		OutputState: i.ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx).OutputState,
	}
}

type DnsManagedZoneIamBindingConditionOutput struct{ *pulumi.OutputState }

func (DnsManagedZoneIamBindingConditionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DnsManagedZoneIamBindingCondition)(nil)).Elem()
}

func (o DnsManagedZoneIamBindingConditionOutput) ToDnsManagedZoneIamBindingConditionOutput() DnsManagedZoneIamBindingConditionOutput {
	return o
}

func (o DnsManagedZoneIamBindingConditionOutput) ToDnsManagedZoneIamBindingConditionOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionOutput {
	return o
}

func (o DnsManagedZoneIamBindingConditionOutput) ToDnsManagedZoneIamBindingConditionPtrOutput() DnsManagedZoneIamBindingConditionPtrOutput {
	return o.ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(context.Background())
}

func (o DnsManagedZoneIamBindingConditionOutput) ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DnsManagedZoneIamBindingCondition) *DnsManagedZoneIamBindingCondition {
		return &v
	}).(DnsManagedZoneIamBindingConditionPtrOutput)
}

func (o DnsManagedZoneIamBindingConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DnsManagedZoneIamBindingCondition] {
	return pulumix.Output[DnsManagedZoneIamBindingCondition]{
		OutputState: o.OutputState,
	}
}

func (o DnsManagedZoneIamBindingConditionOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DnsManagedZoneIamBindingCondition) *string { return v.Description }).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamBindingConditionOutput) Expression() pulumi.StringOutput {
	return o.ApplyT(func(v DnsManagedZoneIamBindingCondition) string { return v.Expression }).(pulumi.StringOutput)
}

func (o DnsManagedZoneIamBindingConditionOutput) Title() pulumi.StringOutput {
	return o.ApplyT(func(v DnsManagedZoneIamBindingCondition) string { return v.Title }).(pulumi.StringOutput)
}

type DnsManagedZoneIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (DnsManagedZoneIamBindingConditionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DnsManagedZoneIamBindingCondition)(nil)).Elem()
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) ToDnsManagedZoneIamBindingConditionPtrOutput() DnsManagedZoneIamBindingConditionPtrOutput {
	return o
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) ToDnsManagedZoneIamBindingConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamBindingConditionPtrOutput {
	return o
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DnsManagedZoneIamBindingCondition] {
	return pulumix.Output[*DnsManagedZoneIamBindingCondition]{
		OutputState: o.OutputState,
	}
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) Elem() DnsManagedZoneIamBindingConditionOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamBindingCondition) DnsManagedZoneIamBindingCondition {
		if v != nil {
			return *v
		}
		var ret DnsManagedZoneIamBindingCondition
		return ret
	}).(DnsManagedZoneIamBindingConditionOutput)
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamBindingCondition) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamBindingCondition) *string {
		if v == nil {
			return nil
		}
		return &v.Expression
	}).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamBindingCondition) *string {
		if v == nil {
			return nil
		}
		return &v.Title
	}).(pulumi.StringPtrOutput)
}

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

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

	ToDnsManagedZoneIamMemberConditionOutput() DnsManagedZoneIamMemberConditionOutput
	ToDnsManagedZoneIamMemberConditionOutputWithContext(context.Context) DnsManagedZoneIamMemberConditionOutput
}

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

func (DnsManagedZoneIamMemberConditionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DnsManagedZoneIamMemberCondition)(nil)).Elem()
}

func (i DnsManagedZoneIamMemberConditionArgs) ToDnsManagedZoneIamMemberConditionOutput() DnsManagedZoneIamMemberConditionOutput {
	return i.ToDnsManagedZoneIamMemberConditionOutputWithContext(context.Background())
}

func (i DnsManagedZoneIamMemberConditionArgs) ToDnsManagedZoneIamMemberConditionOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamMemberConditionOutput)
}

func (i DnsManagedZoneIamMemberConditionArgs) ToOutput(ctx context.Context) pulumix.Output[DnsManagedZoneIamMemberCondition] {
	return pulumix.Output[DnsManagedZoneIamMemberCondition]{
		OutputState: i.ToDnsManagedZoneIamMemberConditionOutputWithContext(ctx).OutputState,
	}
}

func (i DnsManagedZoneIamMemberConditionArgs) ToDnsManagedZoneIamMemberConditionPtrOutput() DnsManagedZoneIamMemberConditionPtrOutput {
	return i.ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(context.Background())
}

func (i DnsManagedZoneIamMemberConditionArgs) ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamMemberConditionOutput).ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx)
}

// DnsManagedZoneIamMemberConditionPtrInput is an input type that accepts DnsManagedZoneIamMemberConditionArgs, DnsManagedZoneIamMemberConditionPtr and DnsManagedZoneIamMemberConditionPtrOutput values.
// You can construct a concrete instance of `DnsManagedZoneIamMemberConditionPtrInput` via:
//
//	        DnsManagedZoneIamMemberConditionArgs{...}
//
//	or:
//
//	        nil
type DnsManagedZoneIamMemberConditionPtrInput interface {
	pulumi.Input

	ToDnsManagedZoneIamMemberConditionPtrOutput() DnsManagedZoneIamMemberConditionPtrOutput
	ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(context.Context) DnsManagedZoneIamMemberConditionPtrOutput
}

type dnsManagedZoneIamMemberConditionPtrType DnsManagedZoneIamMemberConditionArgs

func DnsManagedZoneIamMemberConditionPtr(v *DnsManagedZoneIamMemberConditionArgs) DnsManagedZoneIamMemberConditionPtrInput {
	return (*dnsManagedZoneIamMemberConditionPtrType)(v)
}

func (*dnsManagedZoneIamMemberConditionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DnsManagedZoneIamMemberCondition)(nil)).Elem()
}

func (i *dnsManagedZoneIamMemberConditionPtrType) ToDnsManagedZoneIamMemberConditionPtrOutput() DnsManagedZoneIamMemberConditionPtrOutput {
	return i.ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(context.Background())
}

func (i *dnsManagedZoneIamMemberConditionPtrType) ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DnsManagedZoneIamMemberConditionPtrOutput)
}

func (i *dnsManagedZoneIamMemberConditionPtrType) ToOutput(ctx context.Context) pulumix.Output[*DnsManagedZoneIamMemberCondition] {
	return pulumix.Output[*DnsManagedZoneIamMemberCondition]{
		OutputState: i.ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx).OutputState,
	}
}

type DnsManagedZoneIamMemberConditionOutput struct{ *pulumi.OutputState }

func (DnsManagedZoneIamMemberConditionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DnsManagedZoneIamMemberCondition)(nil)).Elem()
}

func (o DnsManagedZoneIamMemberConditionOutput) ToDnsManagedZoneIamMemberConditionOutput() DnsManagedZoneIamMemberConditionOutput {
	return o
}

func (o DnsManagedZoneIamMemberConditionOutput) ToDnsManagedZoneIamMemberConditionOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionOutput {
	return o
}

func (o DnsManagedZoneIamMemberConditionOutput) ToDnsManagedZoneIamMemberConditionPtrOutput() DnsManagedZoneIamMemberConditionPtrOutput {
	return o.ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(context.Background())
}

func (o DnsManagedZoneIamMemberConditionOutput) ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DnsManagedZoneIamMemberCondition) *DnsManagedZoneIamMemberCondition {
		return &v
	}).(DnsManagedZoneIamMemberConditionPtrOutput)
}

func (o DnsManagedZoneIamMemberConditionOutput) ToOutput(ctx context.Context) pulumix.Output[DnsManagedZoneIamMemberCondition] {
	return pulumix.Output[DnsManagedZoneIamMemberCondition]{
		OutputState: o.OutputState,
	}
}

func (o DnsManagedZoneIamMemberConditionOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DnsManagedZoneIamMemberCondition) *string { return v.Description }).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamMemberConditionOutput) Expression() pulumi.StringOutput {
	return o.ApplyT(func(v DnsManagedZoneIamMemberCondition) string { return v.Expression }).(pulumi.StringOutput)
}

func (o DnsManagedZoneIamMemberConditionOutput) Title() pulumi.StringOutput {
	return o.ApplyT(func(v DnsManagedZoneIamMemberCondition) string { return v.Title }).(pulumi.StringOutput)
}

type DnsManagedZoneIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (DnsManagedZoneIamMemberConditionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DnsManagedZoneIamMemberCondition)(nil)).Elem()
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) ToDnsManagedZoneIamMemberConditionPtrOutput() DnsManagedZoneIamMemberConditionPtrOutput {
	return o
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) ToDnsManagedZoneIamMemberConditionPtrOutputWithContext(ctx context.Context) DnsManagedZoneIamMemberConditionPtrOutput {
	return o
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*DnsManagedZoneIamMemberCondition] {
	return pulumix.Output[*DnsManagedZoneIamMemberCondition]{
		OutputState: o.OutputState,
	}
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) Elem() DnsManagedZoneIamMemberConditionOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamMemberCondition) DnsManagedZoneIamMemberCondition {
		if v != nil {
			return *v
		}
		var ret DnsManagedZoneIamMemberCondition
		return ret
	}).(DnsManagedZoneIamMemberConditionOutput)
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamMemberCondition) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamMemberCondition) *string {
		if v == nil {
			return nil
		}
		return &v.Expression
	}).(pulumi.StringPtrOutput)
}

func (o DnsManagedZoneIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DnsManagedZoneIamMemberCondition) *string {
		if v == nil {
			return nil
		}
		return &v.Title
	}).(pulumi.StringPtrOutput)
}

type ManagedZoneCloudLoggingConfig struct {
	// If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
	EnableLogging bool `pulumi:"enableLogging"`
}

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

	ToManagedZoneCloudLoggingConfigOutput() ManagedZoneCloudLoggingConfigOutput
	ToManagedZoneCloudLoggingConfigOutputWithContext(context.Context) ManagedZoneCloudLoggingConfigOutput
}

type ManagedZoneCloudLoggingConfigArgs struct {
	// If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
	EnableLogging pulumi.BoolInput `pulumi:"enableLogging"`
}

func (ManagedZoneCloudLoggingConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneCloudLoggingConfig)(nil)).Elem()
}

func (i ManagedZoneCloudLoggingConfigArgs) ToManagedZoneCloudLoggingConfigOutput() ManagedZoneCloudLoggingConfigOutput {
	return i.ToManagedZoneCloudLoggingConfigOutputWithContext(context.Background())
}

func (i ManagedZoneCloudLoggingConfigArgs) ToManagedZoneCloudLoggingConfigOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneCloudLoggingConfigOutput)
}

func (i ManagedZoneCloudLoggingConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneCloudLoggingConfig] {
	return pulumix.Output[ManagedZoneCloudLoggingConfig]{
		OutputState: i.ToManagedZoneCloudLoggingConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZoneCloudLoggingConfigArgs) ToManagedZoneCloudLoggingConfigPtrOutput() ManagedZoneCloudLoggingConfigPtrOutput {
	return i.ToManagedZoneCloudLoggingConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZoneCloudLoggingConfigArgs) ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneCloudLoggingConfigOutput).ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx)
}

// ManagedZoneCloudLoggingConfigPtrInput is an input type that accepts ManagedZoneCloudLoggingConfigArgs, ManagedZoneCloudLoggingConfigPtr and ManagedZoneCloudLoggingConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZoneCloudLoggingConfigPtrInput` via:
//
//	        ManagedZoneCloudLoggingConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZoneCloudLoggingConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneCloudLoggingConfigPtrOutput() ManagedZoneCloudLoggingConfigPtrOutput
	ToManagedZoneCloudLoggingConfigPtrOutputWithContext(context.Context) ManagedZoneCloudLoggingConfigPtrOutput
}

type managedZoneCloudLoggingConfigPtrType ManagedZoneCloudLoggingConfigArgs

func ManagedZoneCloudLoggingConfigPtr(v *ManagedZoneCloudLoggingConfigArgs) ManagedZoneCloudLoggingConfigPtrInput {
	return (*managedZoneCloudLoggingConfigPtrType)(v)
}

func (*managedZoneCloudLoggingConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneCloudLoggingConfig)(nil)).Elem()
}

func (i *managedZoneCloudLoggingConfigPtrType) ToManagedZoneCloudLoggingConfigPtrOutput() ManagedZoneCloudLoggingConfigPtrOutput {
	return i.ToManagedZoneCloudLoggingConfigPtrOutputWithContext(context.Background())
}

func (i *managedZoneCloudLoggingConfigPtrType) ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneCloudLoggingConfigPtrOutput)
}

func (i *managedZoneCloudLoggingConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneCloudLoggingConfig] {
	return pulumix.Output[*ManagedZoneCloudLoggingConfig]{
		OutputState: i.ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneCloudLoggingConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneCloudLoggingConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneCloudLoggingConfig)(nil)).Elem()
}

func (o ManagedZoneCloudLoggingConfigOutput) ToManagedZoneCloudLoggingConfigOutput() ManagedZoneCloudLoggingConfigOutput {
	return o
}

func (o ManagedZoneCloudLoggingConfigOutput) ToManagedZoneCloudLoggingConfigOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigOutput {
	return o
}

func (o ManagedZoneCloudLoggingConfigOutput) ToManagedZoneCloudLoggingConfigPtrOutput() ManagedZoneCloudLoggingConfigPtrOutput {
	return o.ToManagedZoneCloudLoggingConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZoneCloudLoggingConfigOutput) ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZoneCloudLoggingConfig) *ManagedZoneCloudLoggingConfig {
		return &v
	}).(ManagedZoneCloudLoggingConfigPtrOutput)
}

func (o ManagedZoneCloudLoggingConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneCloudLoggingConfig] {
	return pulumix.Output[ManagedZoneCloudLoggingConfig]{
		OutputState: o.OutputState,
	}
}

// If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
func (o ManagedZoneCloudLoggingConfigOutput) EnableLogging() pulumi.BoolOutput {
	return o.ApplyT(func(v ManagedZoneCloudLoggingConfig) bool { return v.EnableLogging }).(pulumi.BoolOutput)
}

type ManagedZoneCloudLoggingConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneCloudLoggingConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneCloudLoggingConfig)(nil)).Elem()
}

func (o ManagedZoneCloudLoggingConfigPtrOutput) ToManagedZoneCloudLoggingConfigPtrOutput() ManagedZoneCloudLoggingConfigPtrOutput {
	return o
}

func (o ManagedZoneCloudLoggingConfigPtrOutput) ToManagedZoneCloudLoggingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneCloudLoggingConfigPtrOutput {
	return o
}

func (o ManagedZoneCloudLoggingConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneCloudLoggingConfig] {
	return pulumix.Output[*ManagedZoneCloudLoggingConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneCloudLoggingConfigPtrOutput) Elem() ManagedZoneCloudLoggingConfigOutput {
	return o.ApplyT(func(v *ManagedZoneCloudLoggingConfig) ManagedZoneCloudLoggingConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZoneCloudLoggingConfig
		return ret
	}).(ManagedZoneCloudLoggingConfigOutput)
}

// If set, enable query logging for this ManagedZone. False by default, making logging opt-in.
func (o ManagedZoneCloudLoggingConfigPtrOutput) EnableLogging() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ManagedZoneCloudLoggingConfig) *bool {
		if v == nil {
			return nil
		}
		return &v.EnableLogging
	}).(pulumi.BoolPtrOutput)
}

type ManagedZoneDnssecConfig struct {
	// Specifies parameters that will be used for generating initial DnsKeys
	// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
	// you must also provide one for the other.
	// defaultKeySpecs can only be updated when the state is `off`.
	// Structure is documented below.
	DefaultKeySpecs []ManagedZoneDnssecConfigDefaultKeySpec `pulumi:"defaultKeySpecs"`
	// Identifies what kind of resource this is
	Kind *string `pulumi:"kind"`
	// Specifies the mechanism used to provide authenticated denial-of-existence responses.
	// nonExistence can only be updated when the state is `off`.
	// Possible values are: `nsec`, `nsec3`.
	NonExistence *string `pulumi:"nonExistence"`
	// Specifies whether DNSSEC is enabled, and what mode it is in
	// Possible values are: `off`, `on`, `transfer`.
	State *string `pulumi:"state"`
}

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

	ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput
	ToManagedZoneDnssecConfigOutputWithContext(context.Context) ManagedZoneDnssecConfigOutput
}

type ManagedZoneDnssecConfigArgs struct {
	// Specifies parameters that will be used for generating initial DnsKeys
	// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
	// you must also provide one for the other.
	// defaultKeySpecs can only be updated when the state is `off`.
	// Structure is documented below.
	DefaultKeySpecs ManagedZoneDnssecConfigDefaultKeySpecArrayInput `pulumi:"defaultKeySpecs"`
	// Identifies what kind of resource this is
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// Specifies the mechanism used to provide authenticated denial-of-existence responses.
	// nonExistence can only be updated when the state is `off`.
	// Possible values are: `nsec`, `nsec3`.
	NonExistence pulumi.StringPtrInput `pulumi:"nonExistence"`
	// Specifies whether DNSSEC is enabled, and what mode it is in
	// Possible values are: `off`, `on`, `transfer`.
	State pulumi.StringPtrInput `pulumi:"state"`
}

func (ManagedZoneDnssecConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneDnssecConfig)(nil)).Elem()
}

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput {
	return i.ToManagedZoneDnssecConfigOutputWithContext(context.Background())
}

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneDnssecConfigOutput)
}

func (i ManagedZoneDnssecConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneDnssecConfig] {
	return pulumix.Output[ManagedZoneDnssecConfig]{
		OutputState: i.ToManagedZoneDnssecConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput {
	return i.ToManagedZoneDnssecConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZoneDnssecConfigArgs) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneDnssecConfigOutput).ToManagedZoneDnssecConfigPtrOutputWithContext(ctx)
}

// ManagedZoneDnssecConfigPtrInput is an input type that accepts ManagedZoneDnssecConfigArgs, ManagedZoneDnssecConfigPtr and ManagedZoneDnssecConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZoneDnssecConfigPtrInput` via:
//
//	        ManagedZoneDnssecConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZoneDnssecConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput
	ToManagedZoneDnssecConfigPtrOutputWithContext(context.Context) ManagedZoneDnssecConfigPtrOutput
}

type managedZoneDnssecConfigPtrType ManagedZoneDnssecConfigArgs

func ManagedZoneDnssecConfigPtr(v *ManagedZoneDnssecConfigArgs) ManagedZoneDnssecConfigPtrInput {
	return (*managedZoneDnssecConfigPtrType)(v)
}

func (*managedZoneDnssecConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneDnssecConfig)(nil)).Elem()
}

func (i *managedZoneDnssecConfigPtrType) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput {
	return i.ToManagedZoneDnssecConfigPtrOutputWithContext(context.Background())
}

func (i *managedZoneDnssecConfigPtrType) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneDnssecConfigPtrOutput)
}

func (i *managedZoneDnssecConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneDnssecConfig] {
	return pulumix.Output[*ManagedZoneDnssecConfig]{
		OutputState: i.ToManagedZoneDnssecConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneDnssecConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneDnssecConfig)(nil)).Elem()
}

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutput() ManagedZoneDnssecConfigOutput {
	return o
}

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigOutput {
	return o
}

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput {
	return o.ToManagedZoneDnssecConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZoneDnssecConfigOutput) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZoneDnssecConfig) *ManagedZoneDnssecConfig {
		return &v
	}).(ManagedZoneDnssecConfigPtrOutput)
}

func (o ManagedZoneDnssecConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneDnssecConfig] {
	return pulumix.Output[ManagedZoneDnssecConfig]{
		OutputState: o.OutputState,
	}
}

// Specifies parameters that will be used for generating initial DnsKeys
// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
// you must also provide one for the other.
// defaultKeySpecs can only be updated when the state is `off`.
// Structure is documented below.
func (o ManagedZoneDnssecConfigOutput) DefaultKeySpecs() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfig) []ManagedZoneDnssecConfigDefaultKeySpec { return v.DefaultKeySpecs }).(ManagedZoneDnssecConfigDefaultKeySpecArrayOutput)
}

// Identifies what kind of resource this is
func (o ManagedZoneDnssecConfigOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfig) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Specifies the mechanism used to provide authenticated denial-of-existence responses.
// nonExistence can only be updated when the state is `off`.
// Possible values are: `nsec`, `nsec3`.
func (o ManagedZoneDnssecConfigOutput) NonExistence() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfig) *string { return v.NonExistence }).(pulumi.StringPtrOutput)
}

// Specifies whether DNSSEC is enabled, and what mode it is in
// Possible values are: `off`, `on`, `transfer`.
func (o ManagedZoneDnssecConfigOutput) State() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfig) *string { return v.State }).(pulumi.StringPtrOutput)
}

type ManagedZoneDnssecConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneDnssecConfig)(nil)).Elem()
}

func (o ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutput() ManagedZoneDnssecConfigPtrOutput {
	return o
}

func (o ManagedZoneDnssecConfigPtrOutput) ToManagedZoneDnssecConfigPtrOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigPtrOutput {
	return o
}

func (o ManagedZoneDnssecConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneDnssecConfig] {
	return pulumix.Output[*ManagedZoneDnssecConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneDnssecConfigPtrOutput) Elem() ManagedZoneDnssecConfigOutput {
	return o.ApplyT(func(v *ManagedZoneDnssecConfig) ManagedZoneDnssecConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZoneDnssecConfig
		return ret
	}).(ManagedZoneDnssecConfigOutput)
}

// Specifies parameters that will be used for generating initial DnsKeys
// for this ManagedZone. If you provide a spec for keySigning or zoneSigning,
// you must also provide one for the other.
// defaultKeySpecs can only be updated when the state is `off`.
// Structure is documented below.
func (o ManagedZoneDnssecConfigPtrOutput) DefaultKeySpecs() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return o.ApplyT(func(v *ManagedZoneDnssecConfig) []ManagedZoneDnssecConfigDefaultKeySpec {
		if v == nil {
			return nil
		}
		return v.DefaultKeySpecs
	}).(ManagedZoneDnssecConfigDefaultKeySpecArrayOutput)
}

// Identifies what kind of resource this is
func (o ManagedZoneDnssecConfigPtrOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedZoneDnssecConfig) *string {
		if v == nil {
			return nil
		}
		return v.Kind
	}).(pulumi.StringPtrOutput)
}

// Specifies the mechanism used to provide authenticated denial-of-existence responses.
// nonExistence can only be updated when the state is `off`.
// Possible values are: `nsec`, `nsec3`.
func (o ManagedZoneDnssecConfigPtrOutput) NonExistence() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedZoneDnssecConfig) *string {
		if v == nil {
			return nil
		}
		return v.NonExistence
	}).(pulumi.StringPtrOutput)
}

// Specifies whether DNSSEC is enabled, and what mode it is in
// Possible values are: `off`, `on`, `transfer`.
func (o ManagedZoneDnssecConfigPtrOutput) State() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedZoneDnssecConfig) *string {
		if v == nil {
			return nil
		}
		return v.State
	}).(pulumi.StringPtrOutput)
}

type ManagedZoneDnssecConfigDefaultKeySpec struct {
	// String mnemonic specifying the DNSSEC algorithm of this key
	// Possible values are: `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, `rsasha512`.
	Algorithm *string `pulumi:"algorithm"`
	// Length of the keys in bits
	KeyLength *int `pulumi:"keyLength"`
	// Specifies whether this is a key signing key (KSK) or a zone
	// signing key (ZSK). Key signing keys have the Secure Entry
	// Point flag set and, when active, will only be used to sign
	// resource record sets of type DNSKEY. Zone signing keys do
	// not have the Secure Entry Point flag set and will be used
	// to sign all other types of resource record sets.
	// Possible values are: `keySigning`, `zoneSigning`.
	KeyType *string `pulumi:"keyType"`
	// Identifies what kind of resource this is
	Kind *string `pulumi:"kind"`
}

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

	ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput
	ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput
}

type ManagedZoneDnssecConfigDefaultKeySpecArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key
	// Possible values are: `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, `rsasha512`.
	Algorithm pulumi.StringPtrInput `pulumi:"algorithm"`
	// Length of the keys in bits
	KeyLength pulumi.IntPtrInput `pulumi:"keyLength"`
	// Specifies whether this is a key signing key (KSK) or a zone
	// signing key (ZSK). Key signing keys have the Secure Entry
	// Point flag set and, when active, will only be used to sign
	// resource record sets of type DNSKEY. Zone signing keys do
	// not have the Secure Entry Point flag set and will be used
	// to sign all other types of resource record sets.
	// Possible values are: `keySigning`, `zoneSigning`.
	KeyType pulumi.StringPtrInput `pulumi:"keyType"`
	// Identifies what kind of resource this is
	Kind pulumi.StringPtrInput `pulumi:"kind"`
}

func (ManagedZoneDnssecConfigDefaultKeySpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneDnssecConfigDefaultKeySpec)(nil)).Elem()
}

func (i ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput {
	return i.ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(context.Background())
}

func (i ManagedZoneDnssecConfigDefaultKeySpecArgs) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneDnssecConfigDefaultKeySpecOutput)
}

func (i ManagedZoneDnssecConfigDefaultKeySpecArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneDnssecConfigDefaultKeySpec] {
	return pulumix.Output[ManagedZoneDnssecConfigDefaultKeySpec]{
		OutputState: i.ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(ctx).OutputState,
	}
}

// ManagedZoneDnssecConfigDefaultKeySpecArrayInput is an input type that accepts ManagedZoneDnssecConfigDefaultKeySpecArray and ManagedZoneDnssecConfigDefaultKeySpecArrayOutput values.
// You can construct a concrete instance of `ManagedZoneDnssecConfigDefaultKeySpecArrayInput` via:
//
//	ManagedZoneDnssecConfigDefaultKeySpecArray{ ManagedZoneDnssecConfigDefaultKeySpecArgs{...} }
type ManagedZoneDnssecConfigDefaultKeySpecArrayInput interface {
	pulumi.Input

	ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput
	ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput
}

type ManagedZoneDnssecConfigDefaultKeySpecArray []ManagedZoneDnssecConfigDefaultKeySpecInput

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

func (i ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return i.ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(context.Background())
}

func (i ManagedZoneDnssecConfigDefaultKeySpecArray) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneDnssecConfigDefaultKeySpecArrayOutput)
}

func (i ManagedZoneDnssecConfigDefaultKeySpecArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZoneDnssecConfigDefaultKeySpec] {
	return pulumix.Output[[]ManagedZoneDnssecConfigDefaultKeySpec]{
		OutputState: i.ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneDnssecConfigDefaultKeySpecOutput struct{ *pulumi.OutputState }

func (ManagedZoneDnssecConfigDefaultKeySpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneDnssecConfigDefaultKeySpec)(nil)).Elem()
}

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutput() ManagedZoneDnssecConfigDefaultKeySpecOutput {
	return o
}

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) ToManagedZoneDnssecConfigDefaultKeySpecOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecOutput {
	return o
}

func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneDnssecConfigDefaultKeySpec] {
	return pulumix.Output[ManagedZoneDnssecConfigDefaultKeySpec]{
		OutputState: o.OutputState,
	}
}

// String mnemonic specifying the DNSSEC algorithm of this key
// Possible values are: `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, `rsasha512`.
func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) Algorithm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfigDefaultKeySpec) *string { return v.Algorithm }).(pulumi.StringPtrOutput)
}

// Length of the keys in bits
func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyLength() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfigDefaultKeySpec) *int { return v.KeyLength }).(pulumi.IntPtrOutput)
}

// Specifies whether this is a key signing key (KSK) or a zone
// signing key (ZSK). Key signing keys have the Secure Entry
// Point flag set and, when active, will only be used to sign
// resource record sets of type DNSKEY. Zone signing keys do
// not have the Secure Entry Point flag set and will be used
// to sign all other types of resource record sets.
// Possible values are: `keySigning`, `zoneSigning`.
func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) KeyType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfigDefaultKeySpec) *string { return v.KeyType }).(pulumi.StringPtrOutput)
}

// Identifies what kind of resource this is
func (o ManagedZoneDnssecConfigDefaultKeySpecOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneDnssecConfigDefaultKeySpec) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

type ManagedZoneDnssecConfigDefaultKeySpecArrayOutput struct{ *pulumi.OutputState }

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

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutput() ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return o
}

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToManagedZoneDnssecConfigDefaultKeySpecArrayOutputWithContext(ctx context.Context) ManagedZoneDnssecConfigDefaultKeySpecArrayOutput {
	return o
}

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZoneDnssecConfigDefaultKeySpec] {
	return pulumix.Output[[]ManagedZoneDnssecConfigDefaultKeySpec]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneDnssecConfigDefaultKeySpecArrayOutput) Index(i pulumi.IntInput) ManagedZoneDnssecConfigDefaultKeySpecOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedZoneDnssecConfigDefaultKeySpec {
		return vs[0].([]ManagedZoneDnssecConfigDefaultKeySpec)[vs[1].(int)]
	}).(ManagedZoneDnssecConfigDefaultKeySpecOutput)
}

type ManagedZoneForwardingConfig struct {
	// List of target name servers to forward to. Cloud DNS will
	// select the best available name server if more than
	// one target is given.
	// Structure is documented below.
	TargetNameServers []ManagedZoneForwardingConfigTargetNameServer `pulumi:"targetNameServers"`
}

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

	ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput
	ToManagedZoneForwardingConfigOutputWithContext(context.Context) ManagedZoneForwardingConfigOutput
}

type ManagedZoneForwardingConfigArgs struct {
	// List of target name servers to forward to. Cloud DNS will
	// select the best available name server if more than
	// one target is given.
	// Structure is documented below.
	TargetNameServers ManagedZoneForwardingConfigTargetNameServerArrayInput `pulumi:"targetNameServers"`
}

func (ManagedZoneForwardingConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneForwardingConfig)(nil)).Elem()
}

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput {
	return i.ToManagedZoneForwardingConfigOutputWithContext(context.Background())
}

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneForwardingConfigOutput)
}

func (i ManagedZoneForwardingConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneForwardingConfig] {
	return pulumix.Output[ManagedZoneForwardingConfig]{
		OutputState: i.ToManagedZoneForwardingConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput {
	return i.ToManagedZoneForwardingConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZoneForwardingConfigArgs) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneForwardingConfigOutput).ToManagedZoneForwardingConfigPtrOutputWithContext(ctx)
}

// ManagedZoneForwardingConfigPtrInput is an input type that accepts ManagedZoneForwardingConfigArgs, ManagedZoneForwardingConfigPtr and ManagedZoneForwardingConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZoneForwardingConfigPtrInput` via:
//
//	        ManagedZoneForwardingConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZoneForwardingConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput
	ToManagedZoneForwardingConfigPtrOutputWithContext(context.Context) ManagedZoneForwardingConfigPtrOutput
}

type managedZoneForwardingConfigPtrType ManagedZoneForwardingConfigArgs

func ManagedZoneForwardingConfigPtr(v *ManagedZoneForwardingConfigArgs) ManagedZoneForwardingConfigPtrInput {
	return (*managedZoneForwardingConfigPtrType)(v)
}

func (*managedZoneForwardingConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneForwardingConfig)(nil)).Elem()
}

func (i *managedZoneForwardingConfigPtrType) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput {
	return i.ToManagedZoneForwardingConfigPtrOutputWithContext(context.Background())
}

func (i *managedZoneForwardingConfigPtrType) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneForwardingConfigPtrOutput)
}

func (i *managedZoneForwardingConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneForwardingConfig] {
	return pulumix.Output[*ManagedZoneForwardingConfig]{
		OutputState: i.ToManagedZoneForwardingConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneForwardingConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneForwardingConfig)(nil)).Elem()
}

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutput() ManagedZoneForwardingConfigOutput {
	return o
}

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigOutput {
	return o
}

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput {
	return o.ToManagedZoneForwardingConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZoneForwardingConfigOutput) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZoneForwardingConfig) *ManagedZoneForwardingConfig {
		return &v
	}).(ManagedZoneForwardingConfigPtrOutput)
}

func (o ManagedZoneForwardingConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneForwardingConfig] {
	return pulumix.Output[ManagedZoneForwardingConfig]{
		OutputState: o.OutputState,
	}
}

// List of target name servers to forward to. Cloud DNS will
// select the best available name server if more than
// one target is given.
// Structure is documented below.
func (o ManagedZoneForwardingConfigOutput) TargetNameServers() ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return o.ApplyT(func(v ManagedZoneForwardingConfig) []ManagedZoneForwardingConfigTargetNameServer {
		return v.TargetNameServers
	}).(ManagedZoneForwardingConfigTargetNameServerArrayOutput)
}

type ManagedZoneForwardingConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneForwardingConfig)(nil)).Elem()
}

func (o ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutput() ManagedZoneForwardingConfigPtrOutput {
	return o
}

func (o ManagedZoneForwardingConfigPtrOutput) ToManagedZoneForwardingConfigPtrOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigPtrOutput {
	return o
}

func (o ManagedZoneForwardingConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneForwardingConfig] {
	return pulumix.Output[*ManagedZoneForwardingConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneForwardingConfigPtrOutput) Elem() ManagedZoneForwardingConfigOutput {
	return o.ApplyT(func(v *ManagedZoneForwardingConfig) ManagedZoneForwardingConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZoneForwardingConfig
		return ret
	}).(ManagedZoneForwardingConfigOutput)
}

// List of target name servers to forward to. Cloud DNS will
// select the best available name server if more than
// one target is given.
// Structure is documented below.
func (o ManagedZoneForwardingConfigPtrOutput) TargetNameServers() ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return o.ApplyT(func(v *ManagedZoneForwardingConfig) []ManagedZoneForwardingConfigTargetNameServer {
		if v == nil {
			return nil
		}
		return v.TargetNameServers
	}).(ManagedZoneForwardingConfigTargetNameServerArrayOutput)
}

type ManagedZoneForwardingConfigTargetNameServer struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are: `default`, `private`.
	ForwardingPath *string `pulumi:"forwardingPath"`
	// IPv4 address of a target name server.
	Ipv4Address string `pulumi:"ipv4Address"`
}

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

	ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput
	ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(context.Context) ManagedZoneForwardingConfigTargetNameServerOutput
}

type ManagedZoneForwardingConfigTargetNameServerArgs struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are: `default`, `private`.
	ForwardingPath pulumi.StringPtrInput `pulumi:"forwardingPath"`
	// IPv4 address of a target name server.
	Ipv4Address pulumi.StringInput `pulumi:"ipv4Address"`
}

func (ManagedZoneForwardingConfigTargetNameServerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneForwardingConfigTargetNameServer)(nil)).Elem()
}

func (i ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput {
	return i.ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(context.Background())
}

func (i ManagedZoneForwardingConfigTargetNameServerArgs) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneForwardingConfigTargetNameServerOutput)
}

func (i ManagedZoneForwardingConfigTargetNameServerArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneForwardingConfigTargetNameServer] {
	return pulumix.Output[ManagedZoneForwardingConfigTargetNameServer]{
		OutputState: i.ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(ctx).OutputState,
	}
}

// ManagedZoneForwardingConfigTargetNameServerArrayInput is an input type that accepts ManagedZoneForwardingConfigTargetNameServerArray and ManagedZoneForwardingConfigTargetNameServerArrayOutput values.
// You can construct a concrete instance of `ManagedZoneForwardingConfigTargetNameServerArrayInput` via:
//
//	ManagedZoneForwardingConfigTargetNameServerArray{ ManagedZoneForwardingConfigTargetNameServerArgs{...} }
type ManagedZoneForwardingConfigTargetNameServerArrayInput interface {
	pulumi.Input

	ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput
	ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput
}

type ManagedZoneForwardingConfigTargetNameServerArray []ManagedZoneForwardingConfigTargetNameServerInput

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

func (i ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return i.ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(context.Background())
}

func (i ManagedZoneForwardingConfigTargetNameServerArray) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneForwardingConfigTargetNameServerArrayOutput)
}

func (i ManagedZoneForwardingConfigTargetNameServerArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZoneForwardingConfigTargetNameServer] {
	return pulumix.Output[[]ManagedZoneForwardingConfigTargetNameServer]{
		OutputState: i.ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneForwardingConfigTargetNameServerOutput struct{ *pulumi.OutputState }

func (ManagedZoneForwardingConfigTargetNameServerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneForwardingConfigTargetNameServer)(nil)).Elem()
}

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutput() ManagedZoneForwardingConfigTargetNameServerOutput {
	return o
}

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ToManagedZoneForwardingConfigTargetNameServerOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerOutput {
	return o
}

func (o ManagedZoneForwardingConfigTargetNameServerOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneForwardingConfigTargetNameServer] {
	return pulumix.Output[ManagedZoneForwardingConfigTargetNameServer]{
		OutputState: o.OutputState,
	}
}

// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
// Possible values are: `default`, `private`.
func (o ManagedZoneForwardingConfigTargetNameServerOutput) ForwardingPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ManagedZoneForwardingConfigTargetNameServer) *string { return v.ForwardingPath }).(pulumi.StringPtrOutput)
}

// IPv4 address of a target name server.
func (o ManagedZoneForwardingConfigTargetNameServerOutput) Ipv4Address() pulumi.StringOutput {
	return o.ApplyT(func(v ManagedZoneForwardingConfigTargetNameServer) string { return v.Ipv4Address }).(pulumi.StringOutput)
}

type ManagedZoneForwardingConfigTargetNameServerArrayOutput struct{ *pulumi.OutputState }

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

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutput() ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return o
}

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToManagedZoneForwardingConfigTargetNameServerArrayOutputWithContext(ctx context.Context) ManagedZoneForwardingConfigTargetNameServerArrayOutput {
	return o
}

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZoneForwardingConfigTargetNameServer] {
	return pulumix.Output[[]ManagedZoneForwardingConfigTargetNameServer]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneForwardingConfigTargetNameServerArrayOutput) Index(i pulumi.IntInput) ManagedZoneForwardingConfigTargetNameServerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedZoneForwardingConfigTargetNameServer {
		return vs[0].([]ManagedZoneForwardingConfigTargetNameServer)[vs[1].(int)]
	}).(ManagedZoneForwardingConfigTargetNameServerOutput)
}

type ManagedZonePeeringConfig struct {
	// The network with which to peer.
	// Structure is documented below.
	TargetNetwork ManagedZonePeeringConfigTargetNetwork `pulumi:"targetNetwork"`
}

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

	ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput
	ToManagedZonePeeringConfigOutputWithContext(context.Context) ManagedZonePeeringConfigOutput
}

type ManagedZonePeeringConfigArgs struct {
	// The network with which to peer.
	// Structure is documented below.
	TargetNetwork ManagedZonePeeringConfigTargetNetworkInput `pulumi:"targetNetwork"`
}

func (ManagedZonePeeringConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePeeringConfig)(nil)).Elem()
}

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput {
	return i.ToManagedZonePeeringConfigOutputWithContext(context.Background())
}

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigOutputWithContext(ctx context.Context) ManagedZonePeeringConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigOutput)
}

func (i ManagedZonePeeringConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePeeringConfig] {
	return pulumix.Output[ManagedZonePeeringConfig]{
		OutputState: i.ToManagedZonePeeringConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput {
	return i.ToManagedZonePeeringConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZonePeeringConfigArgs) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigOutput).ToManagedZonePeeringConfigPtrOutputWithContext(ctx)
}

// ManagedZonePeeringConfigPtrInput is an input type that accepts ManagedZonePeeringConfigArgs, ManagedZonePeeringConfigPtr and ManagedZonePeeringConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZonePeeringConfigPtrInput` via:
//
//	        ManagedZonePeeringConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZonePeeringConfigPtrInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput
	ToManagedZonePeeringConfigPtrOutputWithContext(context.Context) ManagedZonePeeringConfigPtrOutput
}

type managedZonePeeringConfigPtrType ManagedZonePeeringConfigArgs

func ManagedZonePeeringConfigPtr(v *ManagedZonePeeringConfigArgs) ManagedZonePeeringConfigPtrInput {
	return (*managedZonePeeringConfigPtrType)(v)
}

func (*managedZonePeeringConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePeeringConfig)(nil)).Elem()
}

func (i *managedZonePeeringConfigPtrType) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput {
	return i.ToManagedZonePeeringConfigPtrOutputWithContext(context.Background())
}

func (i *managedZonePeeringConfigPtrType) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigPtrOutput)
}

func (i *managedZonePeeringConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePeeringConfig] {
	return pulumix.Output[*ManagedZonePeeringConfig]{
		OutputState: i.ToManagedZonePeeringConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZonePeeringConfigOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePeeringConfig)(nil)).Elem()
}

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutput() ManagedZonePeeringConfigOutput {
	return o
}

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigOutputWithContext(ctx context.Context) ManagedZonePeeringConfigOutput {
	return o
}

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput {
	return o.ToManagedZonePeeringConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZonePeeringConfigOutput) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZonePeeringConfig) *ManagedZonePeeringConfig {
		return &v
	}).(ManagedZonePeeringConfigPtrOutput)
}

func (o ManagedZonePeeringConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePeeringConfig] {
	return pulumix.Output[ManagedZonePeeringConfig]{
		OutputState: o.OutputState,
	}
}

// The network with which to peer.
// Structure is documented below.
func (o ManagedZonePeeringConfigOutput) TargetNetwork() ManagedZonePeeringConfigTargetNetworkOutput {
	return o.ApplyT(func(v ManagedZonePeeringConfig) ManagedZonePeeringConfigTargetNetwork { return v.TargetNetwork }).(ManagedZonePeeringConfigTargetNetworkOutput)
}

type ManagedZonePeeringConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePeeringConfig)(nil)).Elem()
}

func (o ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutput() ManagedZonePeeringConfigPtrOutput {
	return o
}

func (o ManagedZonePeeringConfigPtrOutput) ToManagedZonePeeringConfigPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigPtrOutput {
	return o
}

func (o ManagedZonePeeringConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePeeringConfig] {
	return pulumix.Output[*ManagedZonePeeringConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZonePeeringConfigPtrOutput) Elem() ManagedZonePeeringConfigOutput {
	return o.ApplyT(func(v *ManagedZonePeeringConfig) ManagedZonePeeringConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZonePeeringConfig
		return ret
	}).(ManagedZonePeeringConfigOutput)
}

// The network with which to peer.
// Structure is documented below.
func (o ManagedZonePeeringConfigPtrOutput) TargetNetwork() ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return o.ApplyT(func(v *ManagedZonePeeringConfig) *ManagedZonePeeringConfigTargetNetwork {
		if v == nil {
			return nil
		}
		return &v.TargetNetwork
	}).(ManagedZonePeeringConfigTargetNetworkPtrOutput)
}

type ManagedZonePeeringConfigTargetNetwork struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

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

	ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput
	ToManagedZonePeeringConfigTargetNetworkOutputWithContext(context.Context) ManagedZonePeeringConfigTargetNetworkOutput
}

type ManagedZonePeeringConfigTargetNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (ManagedZonePeeringConfigTargetNetworkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePeeringConfigTargetNetwork)(nil)).Elem()
}

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput {
	return i.ToManagedZonePeeringConfigTargetNetworkOutputWithContext(context.Background())
}

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigTargetNetworkOutput)
}

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePeeringConfigTargetNetwork] {
	return pulumix.Output[ManagedZonePeeringConfigTargetNetwork]{
		OutputState: i.ToManagedZonePeeringConfigTargetNetworkOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return i.ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(context.Background())
}

func (i ManagedZonePeeringConfigTargetNetworkArgs) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigTargetNetworkOutput).ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx)
}

// ManagedZonePeeringConfigTargetNetworkPtrInput is an input type that accepts ManagedZonePeeringConfigTargetNetworkArgs, ManagedZonePeeringConfigTargetNetworkPtr and ManagedZonePeeringConfigTargetNetworkPtrOutput values.
// You can construct a concrete instance of `ManagedZonePeeringConfigTargetNetworkPtrInput` via:
//
//	        ManagedZonePeeringConfigTargetNetworkArgs{...}
//
//	or:
//
//	        nil
type ManagedZonePeeringConfigTargetNetworkPtrInput interface {
	pulumi.Input

	ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput
	ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput
}

type managedZonePeeringConfigTargetNetworkPtrType ManagedZonePeeringConfigTargetNetworkArgs

func ManagedZonePeeringConfigTargetNetworkPtr(v *ManagedZonePeeringConfigTargetNetworkArgs) ManagedZonePeeringConfigTargetNetworkPtrInput {
	return (*managedZonePeeringConfigTargetNetworkPtrType)(v)
}

func (*managedZonePeeringConfigTargetNetworkPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePeeringConfigTargetNetwork)(nil)).Elem()
}

func (i *managedZonePeeringConfigTargetNetworkPtrType) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return i.ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(context.Background())
}

func (i *managedZonePeeringConfigTargetNetworkPtrType) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePeeringConfigTargetNetworkPtrOutput)
}

func (i *managedZonePeeringConfigTargetNetworkPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePeeringConfigTargetNetwork] {
	return pulumix.Output[*ManagedZonePeeringConfigTargetNetwork]{
		OutputState: i.ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZonePeeringConfigTargetNetworkOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigTargetNetworkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePeeringConfigTargetNetwork)(nil)).Elem()
}

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutput() ManagedZonePeeringConfigTargetNetworkOutput {
	return o
}

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkOutput {
	return o
}

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return o.ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(context.Background())
}

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZonePeeringConfigTargetNetwork) *ManagedZonePeeringConfigTargetNetwork {
		return &v
	}).(ManagedZonePeeringConfigTargetNetworkPtrOutput)
}

func (o ManagedZonePeeringConfigTargetNetworkOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePeeringConfigTargetNetwork] {
	return pulumix.Output[ManagedZonePeeringConfigTargetNetwork]{
		OutputState: o.OutputState,
	}
}

// The id or fully qualified URL of the VPC network to forward queries to.
// This should be formatted like `projects/{project}/global/networks/{network}` or
// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
func (o ManagedZonePeeringConfigTargetNetworkOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v ManagedZonePeeringConfigTargetNetwork) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

type ManagedZonePeeringConfigTargetNetworkPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePeeringConfigTargetNetworkPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePeeringConfigTargetNetwork)(nil)).Elem()
}

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutput() ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return o
}

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) ToManagedZonePeeringConfigTargetNetworkPtrOutputWithContext(ctx context.Context) ManagedZonePeeringConfigTargetNetworkPtrOutput {
	return o
}

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePeeringConfigTargetNetwork] {
	return pulumix.Output[*ManagedZonePeeringConfigTargetNetwork]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) Elem() ManagedZonePeeringConfigTargetNetworkOutput {
	return o.ApplyT(func(v *ManagedZonePeeringConfigTargetNetwork) ManagedZonePeeringConfigTargetNetwork {
		if v != nil {
			return *v
		}
		var ret ManagedZonePeeringConfigTargetNetwork
		return ret
	}).(ManagedZonePeeringConfigTargetNetworkOutput)
}

// The id or fully qualified URL of the VPC network to forward queries to.
// This should be formatted like `projects/{project}/global/networks/{network}` or
// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
func (o ManagedZonePeeringConfigTargetNetworkPtrOutput) NetworkUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedZonePeeringConfigTargetNetwork) *string {
		if v == nil {
			return nil
		}
		return &v.NetworkUrl
	}).(pulumi.StringPtrOutput)
}

type ManagedZonePrivateVisibilityConfig struct {
	// The list of Google Kubernetes Engine clusters that can see this zone.
	// Structure is documented below.
	GkeClusters []ManagedZonePrivateVisibilityConfigGkeCluster `pulumi:"gkeClusters"`
	Networks    []ManagedZonePrivateVisibilityConfigNetwork    `pulumi:"networks"`
}

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

	ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput
	ToManagedZonePrivateVisibilityConfigOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigOutput
}

type ManagedZonePrivateVisibilityConfigArgs struct {
	// The list of Google Kubernetes Engine clusters that can see this zone.
	// Structure is documented below.
	GkeClusters ManagedZonePrivateVisibilityConfigGkeClusterArrayInput `pulumi:"gkeClusters"`
	Networks    ManagedZonePrivateVisibilityConfigNetworkArrayInput    `pulumi:"networks"`
}

func (ManagedZonePrivateVisibilityConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfig)(nil)).Elem()
}

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput {
	return i.ToManagedZonePrivateVisibilityConfigOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigOutput)
}

func (i ManagedZonePrivateVisibilityConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfig] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfig]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput {
	return i.ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigArgs) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigOutput).ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx)
}

// ManagedZonePrivateVisibilityConfigPtrInput is an input type that accepts ManagedZonePrivateVisibilityConfigArgs, ManagedZonePrivateVisibilityConfigPtr and ManagedZonePrivateVisibilityConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigPtrInput` via:
//
//	        ManagedZonePrivateVisibilityConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZonePrivateVisibilityConfigPtrInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput
	ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigPtrOutput
}

type managedZonePrivateVisibilityConfigPtrType ManagedZonePrivateVisibilityConfigArgs

func ManagedZonePrivateVisibilityConfigPtr(v *ManagedZonePrivateVisibilityConfigArgs) ManagedZonePrivateVisibilityConfigPtrInput {
	return (*managedZonePrivateVisibilityConfigPtrType)(v)
}

func (*managedZonePrivateVisibilityConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePrivateVisibilityConfig)(nil)).Elem()
}

func (i *managedZonePrivateVisibilityConfigPtrType) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput {
	return i.ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(context.Background())
}

func (i *managedZonePrivateVisibilityConfigPtrType) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigPtrOutput)
}

func (i *managedZonePrivateVisibilityConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePrivateVisibilityConfig] {
	return pulumix.Output[*ManagedZonePrivateVisibilityConfig]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZonePrivateVisibilityConfigOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfig)(nil)).Elem()
}

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutput() ManagedZonePrivateVisibilityConfigOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput {
	return o.ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZonePrivateVisibilityConfigOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZonePrivateVisibilityConfig) *ManagedZonePrivateVisibilityConfig {
		return &v
	}).(ManagedZonePrivateVisibilityConfigPtrOutput)
}

func (o ManagedZonePrivateVisibilityConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfig] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfig]{
		OutputState: o.OutputState,
	}
}

// The list of Google Kubernetes Engine clusters that can see this zone.
// Structure is documented below.
func (o ManagedZonePrivateVisibilityConfigOutput) GkeClusters() ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return o.ApplyT(func(v ManagedZonePrivateVisibilityConfig) []ManagedZonePrivateVisibilityConfigGkeCluster {
		return v.GkeClusters
	}).(ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput)
}

func (o ManagedZonePrivateVisibilityConfigOutput) Networks() ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return o.ApplyT(func(v ManagedZonePrivateVisibilityConfig) []ManagedZonePrivateVisibilityConfigNetwork {
		return v.Networks
	}).(ManagedZonePrivateVisibilityConfigNetworkArrayOutput)
}

type ManagedZonePrivateVisibilityConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZonePrivateVisibilityConfig)(nil)).Elem()
}

func (o ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutput() ManagedZonePrivateVisibilityConfigPtrOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigPtrOutput) ToManagedZonePrivateVisibilityConfigPtrOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigPtrOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZonePrivateVisibilityConfig] {
	return pulumix.Output[*ManagedZonePrivateVisibilityConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZonePrivateVisibilityConfigPtrOutput) Elem() ManagedZonePrivateVisibilityConfigOutput {
	return o.ApplyT(func(v *ManagedZonePrivateVisibilityConfig) ManagedZonePrivateVisibilityConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZonePrivateVisibilityConfig
		return ret
	}).(ManagedZonePrivateVisibilityConfigOutput)
}

// The list of Google Kubernetes Engine clusters that can see this zone.
// Structure is documented below.
func (o ManagedZonePrivateVisibilityConfigPtrOutput) GkeClusters() ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return o.ApplyT(func(v *ManagedZonePrivateVisibilityConfig) []ManagedZonePrivateVisibilityConfigGkeCluster {
		if v == nil {
			return nil
		}
		return v.GkeClusters
	}).(ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput)
}

func (o ManagedZonePrivateVisibilityConfigPtrOutput) Networks() ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return o.ApplyT(func(v *ManagedZonePrivateVisibilityConfig) []ManagedZonePrivateVisibilityConfigNetwork {
		if v == nil {
			return nil
		}
		return v.Networks
	}).(ManagedZonePrivateVisibilityConfigNetworkArrayOutput)
}

type ManagedZonePrivateVisibilityConfigGkeCluster struct {
	// The resource name of the cluster to bind this ManagedZone to.
	// This should be specified in the format like
	// `projects/*/locations/*/clusters/*`
	GkeClusterName string `pulumi:"gkeClusterName"`
}

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

	ToManagedZonePrivateVisibilityConfigGkeClusterOutput() ManagedZonePrivateVisibilityConfigGkeClusterOutput
	ToManagedZonePrivateVisibilityConfigGkeClusterOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigGkeClusterOutput
}

type ManagedZonePrivateVisibilityConfigGkeClusterArgs struct {
	// The resource name of the cluster to bind this ManagedZone to.
	// This should be specified in the format like
	// `projects/*/locations/*/clusters/*`
	GkeClusterName pulumi.StringInput `pulumi:"gkeClusterName"`
}

func (ManagedZonePrivateVisibilityConfigGkeClusterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfigGkeCluster)(nil)).Elem()
}

func (i ManagedZonePrivateVisibilityConfigGkeClusterArgs) ToManagedZonePrivateVisibilityConfigGkeClusterOutput() ManagedZonePrivateVisibilityConfigGkeClusterOutput {
	return i.ToManagedZonePrivateVisibilityConfigGkeClusterOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigGkeClusterArgs) ToManagedZonePrivateVisibilityConfigGkeClusterOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigGkeClusterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigGkeClusterOutput)
}

func (i ManagedZonePrivateVisibilityConfigGkeClusterArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfigGkeCluster] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfigGkeCluster]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigGkeClusterOutputWithContext(ctx).OutputState,
	}
}

// ManagedZonePrivateVisibilityConfigGkeClusterArrayInput is an input type that accepts ManagedZonePrivateVisibilityConfigGkeClusterArray and ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput values.
// You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigGkeClusterArrayInput` via:
//
//	ManagedZonePrivateVisibilityConfigGkeClusterArray{ ManagedZonePrivateVisibilityConfigGkeClusterArgs{...} }
type ManagedZonePrivateVisibilityConfigGkeClusterArrayInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutput() ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput
	ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput
}

type ManagedZonePrivateVisibilityConfigGkeClusterArray []ManagedZonePrivateVisibilityConfigGkeClusterInput

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

func (i ManagedZonePrivateVisibilityConfigGkeClusterArray) ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutput() ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return i.ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigGkeClusterArray) ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput)
}

func (i ManagedZonePrivateVisibilityConfigGkeClusterArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZonePrivateVisibilityConfigGkeCluster] {
	return pulumix.Output[[]ManagedZonePrivateVisibilityConfigGkeCluster]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutputWithContext(ctx).OutputState,
	}
}

type ManagedZonePrivateVisibilityConfigGkeClusterOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigGkeClusterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfigGkeCluster)(nil)).Elem()
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterOutput) ToManagedZonePrivateVisibilityConfigGkeClusterOutput() ManagedZonePrivateVisibilityConfigGkeClusterOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterOutput) ToManagedZonePrivateVisibilityConfigGkeClusterOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigGkeClusterOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfigGkeCluster] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfigGkeCluster]{
		OutputState: o.OutputState,
	}
}

// The resource name of the cluster to bind this ManagedZone to.
// This should be specified in the format like
// `projects/*/locations/*/clusters/*`
func (o ManagedZonePrivateVisibilityConfigGkeClusterOutput) GkeClusterName() pulumi.StringOutput {
	return o.ApplyT(func(v ManagedZonePrivateVisibilityConfigGkeCluster) string { return v.GkeClusterName }).(pulumi.StringOutput)
}

type ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput struct{ *pulumi.OutputState }

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

func (o ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput) ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutput() ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput) ToManagedZonePrivateVisibilityConfigGkeClusterArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZonePrivateVisibilityConfigGkeCluster] {
	return pulumix.Output[[]ManagedZonePrivateVisibilityConfigGkeCluster]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput) Index(i pulumi.IntInput) ManagedZonePrivateVisibilityConfigGkeClusterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedZonePrivateVisibilityConfigGkeCluster {
		return vs[0].([]ManagedZonePrivateVisibilityConfigGkeCluster)[vs[1].(int)]
	}).(ManagedZonePrivateVisibilityConfigGkeClusterOutput)
}

type ManagedZonePrivateVisibilityConfigNetwork struct {
	// The id or fully qualified URL of the VPC network to bind to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

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

	ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput
	ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput
}

type ManagedZonePrivateVisibilityConfigNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to bind to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (ManagedZonePrivateVisibilityConfigNetworkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfigNetwork)(nil)).Elem()
}

func (i ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput {
	return i.ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigNetworkArgs) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigNetworkOutput)
}

func (i ManagedZonePrivateVisibilityConfigNetworkArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfigNetwork] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfigNetwork]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(ctx).OutputState,
	}
}

// ManagedZonePrivateVisibilityConfigNetworkArrayInput is an input type that accepts ManagedZonePrivateVisibilityConfigNetworkArray and ManagedZonePrivateVisibilityConfigNetworkArrayOutput values.
// You can construct a concrete instance of `ManagedZonePrivateVisibilityConfigNetworkArrayInput` via:
//
//	ManagedZonePrivateVisibilityConfigNetworkArray{ ManagedZonePrivateVisibilityConfigNetworkArgs{...} }
type ManagedZonePrivateVisibilityConfigNetworkArrayInput interface {
	pulumi.Input

	ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput
	ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput
}

type ManagedZonePrivateVisibilityConfigNetworkArray []ManagedZonePrivateVisibilityConfigNetworkInput

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

func (i ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return i.ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(context.Background())
}

func (i ManagedZonePrivateVisibilityConfigNetworkArray) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZonePrivateVisibilityConfigNetworkArrayOutput)
}

func (i ManagedZonePrivateVisibilityConfigNetworkArray) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZonePrivateVisibilityConfigNetwork] {
	return pulumix.Output[[]ManagedZonePrivateVisibilityConfigNetwork]{
		OutputState: i.ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(ctx).OutputState,
	}
}

type ManagedZonePrivateVisibilityConfigNetworkOutput struct{ *pulumi.OutputState }

func (ManagedZonePrivateVisibilityConfigNetworkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZonePrivateVisibilityConfigNetwork)(nil)).Elem()
}

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutput() ManagedZonePrivateVisibilityConfigNetworkOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) ToManagedZonePrivateVisibilityConfigNetworkOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigNetworkOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZonePrivateVisibilityConfigNetwork] {
	return pulumix.Output[ManagedZonePrivateVisibilityConfigNetwork]{
		OutputState: o.OutputState,
	}
}

// The id or fully qualified URL of the VPC network to bind to.
// This should be formatted like `projects/{project}/global/networks/{network}` or
// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
func (o ManagedZonePrivateVisibilityConfigNetworkOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v ManagedZonePrivateVisibilityConfigNetwork) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

type ManagedZonePrivateVisibilityConfigNetworkArrayOutput struct{ *pulumi.OutputState }

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

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutput() ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToManagedZonePrivateVisibilityConfigNetworkArrayOutputWithContext(ctx context.Context) ManagedZonePrivateVisibilityConfigNetworkArrayOutput {
	return o
}

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ManagedZonePrivateVisibilityConfigNetwork] {
	return pulumix.Output[[]ManagedZonePrivateVisibilityConfigNetwork]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZonePrivateVisibilityConfigNetworkArrayOutput) Index(i pulumi.IntInput) ManagedZonePrivateVisibilityConfigNetworkOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ManagedZonePrivateVisibilityConfigNetwork {
		return vs[0].([]ManagedZonePrivateVisibilityConfigNetwork)[vs[1].(int)]
	}).(ManagedZonePrivateVisibilityConfigNetworkOutput)
}

type ManagedZoneServiceDirectoryConfig struct {
	// The namespace associated with the zone.
	// Structure is documented below.
	Namespace ManagedZoneServiceDirectoryConfigNamespace `pulumi:"namespace"`
}

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

	ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput
	ToManagedZoneServiceDirectoryConfigOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigOutput
}

type ManagedZoneServiceDirectoryConfigArgs struct {
	// The namespace associated with the zone.
	// Structure is documented below.
	Namespace ManagedZoneServiceDirectoryConfigNamespaceInput `pulumi:"namespace"`
}

func (ManagedZoneServiceDirectoryConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneServiceDirectoryConfig)(nil)).Elem()
}

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput {
	return i.ToManagedZoneServiceDirectoryConfigOutputWithContext(context.Background())
}

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigOutput)
}

func (i ManagedZoneServiceDirectoryConfigArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneServiceDirectoryConfig] {
	return pulumix.Output[ManagedZoneServiceDirectoryConfig]{
		OutputState: i.ToManagedZoneServiceDirectoryConfigOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput {
	return i.ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(context.Background())
}

func (i ManagedZoneServiceDirectoryConfigArgs) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigOutput).ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx)
}

// ManagedZoneServiceDirectoryConfigPtrInput is an input type that accepts ManagedZoneServiceDirectoryConfigArgs, ManagedZoneServiceDirectoryConfigPtr and ManagedZoneServiceDirectoryConfigPtrOutput values.
// You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigPtrInput` via:
//
//	        ManagedZoneServiceDirectoryConfigArgs{...}
//
//	or:
//
//	        nil
type ManagedZoneServiceDirectoryConfigPtrInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput
	ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigPtrOutput
}

type managedZoneServiceDirectoryConfigPtrType ManagedZoneServiceDirectoryConfigArgs

func ManagedZoneServiceDirectoryConfigPtr(v *ManagedZoneServiceDirectoryConfigArgs) ManagedZoneServiceDirectoryConfigPtrInput {
	return (*managedZoneServiceDirectoryConfigPtrType)(v)
}

func (*managedZoneServiceDirectoryConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneServiceDirectoryConfig)(nil)).Elem()
}

func (i *managedZoneServiceDirectoryConfigPtrType) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput {
	return i.ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(context.Background())
}

func (i *managedZoneServiceDirectoryConfigPtrType) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigPtrOutput)
}

func (i *managedZoneServiceDirectoryConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneServiceDirectoryConfig] {
	return pulumix.Output[*ManagedZoneServiceDirectoryConfig]{
		OutputState: i.ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneServiceDirectoryConfigOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneServiceDirectoryConfig)(nil)).Elem()
}

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutput() ManagedZoneServiceDirectoryConfigOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput {
	return o.ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(context.Background())
}

func (o ManagedZoneServiceDirectoryConfigOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZoneServiceDirectoryConfig) *ManagedZoneServiceDirectoryConfig {
		return &v
	}).(ManagedZoneServiceDirectoryConfigPtrOutput)
}

func (o ManagedZoneServiceDirectoryConfigOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneServiceDirectoryConfig] {
	return pulumix.Output[ManagedZoneServiceDirectoryConfig]{
		OutputState: o.OutputState,
	}
}

// The namespace associated with the zone.
// Structure is documented below.
func (o ManagedZoneServiceDirectoryConfigOutput) Namespace() ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return o.ApplyT(func(v ManagedZoneServiceDirectoryConfig) ManagedZoneServiceDirectoryConfigNamespace {
		return v.Namespace
	}).(ManagedZoneServiceDirectoryConfigNamespaceOutput)
}

type ManagedZoneServiceDirectoryConfigPtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneServiceDirectoryConfig)(nil)).Elem()
}

func (o ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutput() ManagedZoneServiceDirectoryConfigPtrOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigPtrOutput) ToManagedZoneServiceDirectoryConfigPtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigPtrOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneServiceDirectoryConfig] {
	return pulumix.Output[*ManagedZoneServiceDirectoryConfig]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneServiceDirectoryConfigPtrOutput) Elem() ManagedZoneServiceDirectoryConfigOutput {
	return o.ApplyT(func(v *ManagedZoneServiceDirectoryConfig) ManagedZoneServiceDirectoryConfig {
		if v != nil {
			return *v
		}
		var ret ManagedZoneServiceDirectoryConfig
		return ret
	}).(ManagedZoneServiceDirectoryConfigOutput)
}

// The namespace associated with the zone.
// Structure is documented below.
func (o ManagedZoneServiceDirectoryConfigPtrOutput) Namespace() ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return o.ApplyT(func(v *ManagedZoneServiceDirectoryConfig) *ManagedZoneServiceDirectoryConfigNamespace {
		if v == nil {
			return nil
		}
		return &v.Namespace
	}).(ManagedZoneServiceDirectoryConfigNamespacePtrOutput)
}

type ManagedZoneServiceDirectoryConfigNamespace struct {
	// The fully qualified or partial URL of the service directory namespace that should be
	// associated with the zone. This should be formatted like
	// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// Ignored for `public` visibility zones.
	NamespaceUrl string `pulumi:"namespaceUrl"`
}

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

	ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput
	ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput
}

type ManagedZoneServiceDirectoryConfigNamespaceArgs struct {
	// The fully qualified or partial URL of the service directory namespace that should be
	// associated with the zone. This should be formatted like
	// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
	// Ignored for `public` visibility zones.
	NamespaceUrl pulumi.StringInput `pulumi:"namespaceUrl"`
}

func (ManagedZoneServiceDirectoryConfigNamespaceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneServiceDirectoryConfigNamespace)(nil)).Elem()
}

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return i.ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(context.Background())
}

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigNamespaceOutput)
}

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneServiceDirectoryConfigNamespace] {
	return pulumix.Output[ManagedZoneServiceDirectoryConfigNamespace]{
		OutputState: i.ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(ctx).OutputState,
	}
}

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return i.ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(context.Background())
}

func (i ManagedZoneServiceDirectoryConfigNamespaceArgs) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigNamespaceOutput).ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx)
}

// ManagedZoneServiceDirectoryConfigNamespacePtrInput is an input type that accepts ManagedZoneServiceDirectoryConfigNamespaceArgs, ManagedZoneServiceDirectoryConfigNamespacePtr and ManagedZoneServiceDirectoryConfigNamespacePtrOutput values.
// You can construct a concrete instance of `ManagedZoneServiceDirectoryConfigNamespacePtrInput` via:
//
//	        ManagedZoneServiceDirectoryConfigNamespaceArgs{...}
//
//	or:
//
//	        nil
type ManagedZoneServiceDirectoryConfigNamespacePtrInput interface {
	pulumi.Input

	ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput
	ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput
}

type managedZoneServiceDirectoryConfigNamespacePtrType ManagedZoneServiceDirectoryConfigNamespaceArgs

func ManagedZoneServiceDirectoryConfigNamespacePtr(v *ManagedZoneServiceDirectoryConfigNamespaceArgs) ManagedZoneServiceDirectoryConfigNamespacePtrInput {
	return (*managedZoneServiceDirectoryConfigNamespacePtrType)(v)
}

func (*managedZoneServiceDirectoryConfigNamespacePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneServiceDirectoryConfigNamespace)(nil)).Elem()
}

func (i *managedZoneServiceDirectoryConfigNamespacePtrType) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return i.ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(context.Background())
}

func (i *managedZoneServiceDirectoryConfigNamespacePtrType) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedZoneServiceDirectoryConfigNamespacePtrOutput)
}

func (i *managedZoneServiceDirectoryConfigNamespacePtrType) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneServiceDirectoryConfigNamespace] {
	return pulumix.Output[*ManagedZoneServiceDirectoryConfigNamespace]{
		OutputState: i.ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx).OutputState,
	}
}

type ManagedZoneServiceDirectoryConfigNamespaceOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigNamespaceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ManagedZoneServiceDirectoryConfigNamespace)(nil)).Elem()
}

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutput() ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespaceOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return o.ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(context.Background())
}

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ManagedZoneServiceDirectoryConfigNamespace) *ManagedZoneServiceDirectoryConfigNamespace {
		return &v
	}).(ManagedZoneServiceDirectoryConfigNamespacePtrOutput)
}

func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) ToOutput(ctx context.Context) pulumix.Output[ManagedZoneServiceDirectoryConfigNamespace] {
	return pulumix.Output[ManagedZoneServiceDirectoryConfigNamespace]{
		OutputState: o.OutputState,
	}
}

// The fully qualified or partial URL of the service directory namespace that should be
// associated with the zone. This should be formatted like
// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
// Ignored for `public` visibility zones.
func (o ManagedZoneServiceDirectoryConfigNamespaceOutput) NamespaceUrl() pulumi.StringOutput {
	return o.ApplyT(func(v ManagedZoneServiceDirectoryConfigNamespace) string { return v.NamespaceUrl }).(pulumi.StringOutput)
}

type ManagedZoneServiceDirectoryConfigNamespacePtrOutput struct{ *pulumi.OutputState }

func (ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedZoneServiceDirectoryConfigNamespace)(nil)).Elem()
}

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutput() ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToManagedZoneServiceDirectoryConfigNamespacePtrOutputWithContext(ctx context.Context) ManagedZoneServiceDirectoryConfigNamespacePtrOutput {
	return o
}

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedZoneServiceDirectoryConfigNamespace] {
	return pulumix.Output[*ManagedZoneServiceDirectoryConfigNamespace]{
		OutputState: o.OutputState,
	}
}

func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) Elem() ManagedZoneServiceDirectoryConfigNamespaceOutput {
	return o.ApplyT(func(v *ManagedZoneServiceDirectoryConfigNamespace) ManagedZoneServiceDirectoryConfigNamespace {
		if v != nil {
			return *v
		}
		var ret ManagedZoneServiceDirectoryConfigNamespace
		return ret
	}).(ManagedZoneServiceDirectoryConfigNamespaceOutput)
}

// The fully qualified or partial URL of the service directory namespace that should be
// associated with the zone. This should be formatted like
// `https://servicedirectory.googleapis.com/v1/projects/{project}/locations/{location}/namespaces/{namespace_id}`
// or simply `projects/{project}/locations/{location}/namespaces/{namespace_id}`
// Ignored for `public` visibility zones.
func (o ManagedZoneServiceDirectoryConfigNamespacePtrOutput) NamespaceUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedZoneServiceDirectoryConfigNamespace) *string {
		if v == nil {
			return nil
		}
		return &v.NamespaceUrl
	}).(pulumi.StringPtrOutput)
}

type PolicyAlternativeNameServerConfig struct {
	// Sets an alternative name server for the associated networks. When specified,
	// all DNS queries are forwarded to a name server that you choose. Names such as .internal
	// are not available when an alternative name server is specified.
	// Structure is documented below.
	TargetNameServers []PolicyAlternativeNameServerConfigTargetNameServer `pulumi:"targetNameServers"`
}

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

	ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput
	ToPolicyAlternativeNameServerConfigOutputWithContext(context.Context) PolicyAlternativeNameServerConfigOutput
}

type PolicyAlternativeNameServerConfigArgs struct {
	// Sets an alternative name server for the associated networks. When specified,
	// all DNS queries are forwarded to a name server that you choose. Names such as .internal
	// are not available when an alternative name server is specified.
	// Structure is documented below.
	TargetNameServers PolicyAlternativeNameServerConfigTargetNameServerArrayInput `pulumi:"targetNameServers"`
}

func (PolicyAlternativeNameServerConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyAlternativeNameServerConfig)(nil)).Elem()
}

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput {
	return i.ToPolicyAlternativeNameServerConfigOutputWithContext(context.Background())
}

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyAlternativeNameServerConfigOutput)
}

func (i PolicyAlternativeNameServerConfigArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyAlternativeNameServerConfig] {
	return pulumix.Output[PolicyAlternativeNameServerConfig]{
		OutputState: i.ToPolicyAlternativeNameServerConfigOutputWithContext(ctx).OutputState,
	}
}

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput {
	return i.ToPolicyAlternativeNameServerConfigPtrOutputWithContext(context.Background())
}

func (i PolicyAlternativeNameServerConfigArgs) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyAlternativeNameServerConfigOutput).ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx)
}

// PolicyAlternativeNameServerConfigPtrInput is an input type that accepts PolicyAlternativeNameServerConfigArgs, PolicyAlternativeNameServerConfigPtr and PolicyAlternativeNameServerConfigPtrOutput values.
// You can construct a concrete instance of `PolicyAlternativeNameServerConfigPtrInput` via:
//
//	        PolicyAlternativeNameServerConfigArgs{...}
//
//	or:
//
//	        nil
type PolicyAlternativeNameServerConfigPtrInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput
	ToPolicyAlternativeNameServerConfigPtrOutputWithContext(context.Context) PolicyAlternativeNameServerConfigPtrOutput
}

type policyAlternativeNameServerConfigPtrType PolicyAlternativeNameServerConfigArgs

func PolicyAlternativeNameServerConfigPtr(v *PolicyAlternativeNameServerConfigArgs) PolicyAlternativeNameServerConfigPtrInput {
	return (*policyAlternativeNameServerConfigPtrType)(v)
}

func (*policyAlternativeNameServerConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PolicyAlternativeNameServerConfig)(nil)).Elem()
}

func (i *policyAlternativeNameServerConfigPtrType) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput {
	return i.ToPolicyAlternativeNameServerConfigPtrOutputWithContext(context.Background())
}

func (i *policyAlternativeNameServerConfigPtrType) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyAlternativeNameServerConfigPtrOutput)
}

func (i *policyAlternativeNameServerConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*PolicyAlternativeNameServerConfig] {
	return pulumix.Output[*PolicyAlternativeNameServerConfig]{
		OutputState: i.ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx).OutputState,
	}
}

type PolicyAlternativeNameServerConfigOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyAlternativeNameServerConfig)(nil)).Elem()
}

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutput() PolicyAlternativeNameServerConfigOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput {
	return o.ToPolicyAlternativeNameServerConfigPtrOutputWithContext(context.Background())
}

func (o PolicyAlternativeNameServerConfigOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PolicyAlternativeNameServerConfig) *PolicyAlternativeNameServerConfig {
		return &v
	}).(PolicyAlternativeNameServerConfigPtrOutput)
}

func (o PolicyAlternativeNameServerConfigOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyAlternativeNameServerConfig] {
	return pulumix.Output[PolicyAlternativeNameServerConfig]{
		OutputState: o.OutputState,
	}
}

// Sets an alternative name server for the associated networks. When specified,
// all DNS queries are forwarded to a name server that you choose. Names such as .internal
// are not available when an alternative name server is specified.
// Structure is documented below.
func (o PolicyAlternativeNameServerConfigOutput) TargetNameServers() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return o.ApplyT(func(v PolicyAlternativeNameServerConfig) []PolicyAlternativeNameServerConfigTargetNameServer {
		return v.TargetNameServers
	}).(PolicyAlternativeNameServerConfigTargetNameServerArrayOutput)
}

type PolicyAlternativeNameServerConfigPtrOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PolicyAlternativeNameServerConfig)(nil)).Elem()
}

func (o PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutput() PolicyAlternativeNameServerConfigPtrOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigPtrOutput) ToPolicyAlternativeNameServerConfigPtrOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigPtrOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*PolicyAlternativeNameServerConfig] {
	return pulumix.Output[*PolicyAlternativeNameServerConfig]{
		OutputState: o.OutputState,
	}
}

func (o PolicyAlternativeNameServerConfigPtrOutput) Elem() PolicyAlternativeNameServerConfigOutput {
	return o.ApplyT(func(v *PolicyAlternativeNameServerConfig) PolicyAlternativeNameServerConfig {
		if v != nil {
			return *v
		}
		var ret PolicyAlternativeNameServerConfig
		return ret
	}).(PolicyAlternativeNameServerConfigOutput)
}

// Sets an alternative name server for the associated networks. When specified,
// all DNS queries are forwarded to a name server that you choose. Names such as .internal
// are not available when an alternative name server is specified.
// Structure is documented below.
func (o PolicyAlternativeNameServerConfigPtrOutput) TargetNameServers() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return o.ApplyT(func(v *PolicyAlternativeNameServerConfig) []PolicyAlternativeNameServerConfigTargetNameServer {
		if v == nil {
			return nil
		}
		return v.TargetNameServers
	}).(PolicyAlternativeNameServerConfigTargetNameServerArrayOutput)
}

type PolicyAlternativeNameServerConfigTargetNameServer struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are: `default`, `private`.
	ForwardingPath *string `pulumi:"forwardingPath"`
	// IPv4 address to forward to.
	Ipv4Address string `pulumi:"ipv4Address"`
}

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

	ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput
	ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput
}

type PolicyAlternativeNameServerConfigTargetNameServerArgs struct {
	// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
	// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
	// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
	// Possible values are: `default`, `private`.
	ForwardingPath pulumi.StringPtrInput `pulumi:"forwardingPath"`
	// IPv4 address to forward to.
	Ipv4Address pulumi.StringInput `pulumi:"ipv4Address"`
}

func (PolicyAlternativeNameServerConfigTargetNameServerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyAlternativeNameServerConfigTargetNameServer)(nil)).Elem()
}

func (i PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput {
	return i.ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(context.Background())
}

func (i PolicyAlternativeNameServerConfigTargetNameServerArgs) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyAlternativeNameServerConfigTargetNameServerOutput)
}

func (i PolicyAlternativeNameServerConfigTargetNameServerArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyAlternativeNameServerConfigTargetNameServer] {
	return pulumix.Output[PolicyAlternativeNameServerConfigTargetNameServer]{
		OutputState: i.ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(ctx).OutputState,
	}
}

// PolicyAlternativeNameServerConfigTargetNameServerArrayInput is an input type that accepts PolicyAlternativeNameServerConfigTargetNameServerArray and PolicyAlternativeNameServerConfigTargetNameServerArrayOutput values.
// You can construct a concrete instance of `PolicyAlternativeNameServerConfigTargetNameServerArrayInput` via:
//
//	PolicyAlternativeNameServerConfigTargetNameServerArray{ PolicyAlternativeNameServerConfigTargetNameServerArgs{...} }
type PolicyAlternativeNameServerConfigTargetNameServerArrayInput interface {
	pulumi.Input

	ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput
	ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput
}

type PolicyAlternativeNameServerConfigTargetNameServerArray []PolicyAlternativeNameServerConfigTargetNameServerInput

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

func (i PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return i.ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(context.Background())
}

func (i PolicyAlternativeNameServerConfigTargetNameServerArray) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyAlternativeNameServerConfigTargetNameServerArrayOutput)
}

func (i PolicyAlternativeNameServerConfigTargetNameServerArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyAlternativeNameServerConfigTargetNameServer] {
	return pulumix.Output[[]PolicyAlternativeNameServerConfigTargetNameServer]{
		OutputState: i.ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(ctx).OutputState,
	}
}

type PolicyAlternativeNameServerConfigTargetNameServerOutput struct{ *pulumi.OutputState }

func (PolicyAlternativeNameServerConfigTargetNameServerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyAlternativeNameServerConfigTargetNameServer)(nil)).Elem()
}

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutput() PolicyAlternativeNameServerConfigTargetNameServerOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ToPolicyAlternativeNameServerConfigTargetNameServerOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyAlternativeNameServerConfigTargetNameServer] {
	return pulumix.Output[PolicyAlternativeNameServerConfigTargetNameServer]{
		OutputState: o.OutputState,
	}
}

// Forwarding path for this TargetNameServer. If unset or `default` Cloud DNS will make forwarding
// decision based on address ranges, i.e. RFC1918 addresses go to the VPC, Non-RFC1918 addresses go
// to the Internet. When set to `private`, Cloud DNS will always send queries through VPC for this target
// Possible values are: `default`, `private`.
func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) ForwardingPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PolicyAlternativeNameServerConfigTargetNameServer) *string { return v.ForwardingPath }).(pulumi.StringPtrOutput)
}

// IPv4 address to forward to.
func (o PolicyAlternativeNameServerConfigTargetNameServerOutput) Ipv4Address() pulumi.StringOutput {
	return o.ApplyT(func(v PolicyAlternativeNameServerConfigTargetNameServer) string { return v.Ipv4Address }).(pulumi.StringOutput)
}

type PolicyAlternativeNameServerConfigTargetNameServerArrayOutput struct{ *pulumi.OutputState }

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

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutput() PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToPolicyAlternativeNameServerConfigTargetNameServerArrayOutputWithContext(ctx context.Context) PolicyAlternativeNameServerConfigTargetNameServerArrayOutput {
	return o
}

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyAlternativeNameServerConfigTargetNameServer] {
	return pulumix.Output[[]PolicyAlternativeNameServerConfigTargetNameServer]{
		OutputState: o.OutputState,
	}
}

func (o PolicyAlternativeNameServerConfigTargetNameServerArrayOutput) Index(i pulumi.IntInput) PolicyAlternativeNameServerConfigTargetNameServerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyAlternativeNameServerConfigTargetNameServer {
		return vs[0].([]PolicyAlternativeNameServerConfigTargetNameServer)[vs[1].(int)]
	}).(PolicyAlternativeNameServerConfigTargetNameServerOutput)
}

type PolicyNetwork struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

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

	ToPolicyNetworkOutput() PolicyNetworkOutput
	ToPolicyNetworkOutputWithContext(context.Context) PolicyNetworkOutput
}

type PolicyNetworkArgs struct {
	// The id or fully qualified URL of the VPC network to forward queries to.
	// This should be formatted like `projects/{project}/global/networks/{network}` or
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (PolicyNetworkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyNetwork)(nil)).Elem()
}

func (i PolicyNetworkArgs) ToPolicyNetworkOutput() PolicyNetworkOutput {
	return i.ToPolicyNetworkOutputWithContext(context.Background())
}

func (i PolicyNetworkArgs) ToPolicyNetworkOutputWithContext(ctx context.Context) PolicyNetworkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyNetworkOutput)
}

func (i PolicyNetworkArgs) ToOutput(ctx context.Context) pulumix.Output[PolicyNetwork] {
	return pulumix.Output[PolicyNetwork]{
		OutputState: i.ToPolicyNetworkOutputWithContext(ctx).OutputState,
	}
}

// PolicyNetworkArrayInput is an input type that accepts PolicyNetworkArray and PolicyNetworkArrayOutput values.
// You can construct a concrete instance of `PolicyNetworkArrayInput` via:
//
//	PolicyNetworkArray{ PolicyNetworkArgs{...} }
type PolicyNetworkArrayInput interface {
	pulumi.Input

	ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput
	ToPolicyNetworkArrayOutputWithContext(context.Context) PolicyNetworkArrayOutput
}

type PolicyNetworkArray []PolicyNetworkInput

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

func (i PolicyNetworkArray) ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput {
	return i.ToPolicyNetworkArrayOutputWithContext(context.Background())
}

func (i PolicyNetworkArray) ToPolicyNetworkArrayOutputWithContext(ctx context.Context) PolicyNetworkArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PolicyNetworkArrayOutput)
}

func (i PolicyNetworkArray) ToOutput(ctx context.Context) pulumix.Output[[]PolicyNetwork] {
	return pulumix.Output[[]PolicyNetwork]{
		OutputState: i.ToPolicyNetworkArrayOutputWithContext(ctx).OutputState,
	}
}

type PolicyNetworkOutput struct{ *pulumi.OutputState }

func (PolicyNetworkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PolicyNetwork)(nil)).Elem()
}

func (o PolicyNetworkOutput) ToPolicyNetworkOutput() PolicyNetworkOutput {
	return o
}

func (o PolicyNetworkOutput) ToPolicyNetworkOutputWithContext(ctx context.Context) PolicyNetworkOutput {
	return o
}

func (o PolicyNetworkOutput) ToOutput(ctx context.Context) pulumix.Output[PolicyNetwork] {
	return pulumix.Output[PolicyNetwork]{
		OutputState: o.OutputState,
	}
}

// The id or fully qualified URL of the VPC network to forward queries to.
// This should be formatted like `projects/{project}/global/networks/{network}` or
// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
func (o PolicyNetworkOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v PolicyNetwork) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

type PolicyNetworkArrayOutput struct{ *pulumi.OutputState }

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

func (o PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutput() PolicyNetworkArrayOutput {
	return o
}

func (o PolicyNetworkArrayOutput) ToPolicyNetworkArrayOutputWithContext(ctx context.Context) PolicyNetworkArrayOutput {
	return o
}

func (o PolicyNetworkArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]PolicyNetwork] {
	return pulumix.Output[[]PolicyNetwork]{
		OutputState: o.OutputState,
	}
}

func (o PolicyNetworkArrayOutput) Index(i pulumi.IntInput) PolicyNetworkOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PolicyNetwork {
		return vs[0].([]PolicyNetwork)[vs[1].(int)]
	}).(PolicyNetworkOutput)
}

type RecordSetRoutingPolicy struct {
	// Specifies whether to enable fencing for geo queries.
	EnableGeoFencing *bool `pulumi:"enableGeoFencing"`
	// The configuration for Geolocation based routing policy.
	// Structure is document below.
	Geos []RecordSetRoutingPolicyGeo `pulumi:"geos"`
	// The configuration for a primary-backup policy with global to regional failover. Queries are responded to with the global primary targets, but if none of the primary targets are healthy, then we fallback to a regional failover policy.
	// Structure is document below.
	PrimaryBackup *RecordSetRoutingPolicyPrimaryBackup `pulumi:"primaryBackup"`
	// The configuration for Weighted Round Robin based routing policy.
	// Structure is document below.
	Wrrs []RecordSetRoutingPolicyWrr `pulumi:"wrrs"`
}

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

	ToRecordSetRoutingPolicyOutput() RecordSetRoutingPolicyOutput
	ToRecordSetRoutingPolicyOutputWithContext(context.Context) RecordSetRoutingPolicyOutput
}

type RecordSetRoutingPolicyArgs struct {
	// Specifies whether to enable fencing for geo queries.
	EnableGeoFencing pulumi.BoolPtrInput `pulumi:"enableGeoFencing"`
	// The configuration for Geolocation based routing policy.
	// Structure is document below.
	Geos RecordSetRoutingPolicyGeoArrayInput `pulumi:"geos"`
	// The configuration for a primary-backup policy with global to regional failover. Queries are responded to with the global primary targets, but if none of the primary targets are healthy, then we fallback to a regional failover policy.
	// Structure is document below.
	PrimaryBackup RecordSetRoutingPolicyPrimaryBackupPtrInput `pulumi:"primaryBackup"`
	// The configuration for Weighted Round Robin based routing policy.
	// Structure is document below.
	Wrrs RecordSetRoutingPolicyWrrArrayInput `pulumi:"wrrs"`
}

func (RecordSetRoutingPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicy)(nil)).Elem()
}

func (i RecordSetRoutingPolicyArgs) ToRecordSetRoutingPolicyOutput() RecordSetRoutingPolicyOutput {
	return i.ToRecordSetRoutingPolicyOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyArgs) ToRecordSetRoutingPolicyOutputWithContext(ctx context.Context) RecordSetRoutingPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyOutput)
}

func (i RecordSetRoutingPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicy] {
	return pulumix.Output[RecordSetRoutingPolicy]{
		OutputState: i.ToRecordSetRoutingPolicyOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyArgs) ToRecordSetRoutingPolicyPtrOutput() RecordSetRoutingPolicyPtrOutput {
	return i.ToRecordSetRoutingPolicyPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyArgs) ToRecordSetRoutingPolicyPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyOutput).ToRecordSetRoutingPolicyPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyPtrInput is an input type that accepts RecordSetRoutingPolicyArgs, RecordSetRoutingPolicyPtr and RecordSetRoutingPolicyPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPtrInput` via:
//
//	        RecordSetRoutingPolicyArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPtrOutput() RecordSetRoutingPolicyPtrOutput
	ToRecordSetRoutingPolicyPtrOutputWithContext(context.Context) RecordSetRoutingPolicyPtrOutput
}

type recordSetRoutingPolicyPtrType RecordSetRoutingPolicyArgs

func RecordSetRoutingPolicyPtr(v *RecordSetRoutingPolicyArgs) RecordSetRoutingPolicyPtrInput {
	return (*recordSetRoutingPolicyPtrType)(v)
}

func (*recordSetRoutingPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicy)(nil)).Elem()
}

func (i *recordSetRoutingPolicyPtrType) ToRecordSetRoutingPolicyPtrOutput() RecordSetRoutingPolicyPtrOutput {
	return i.ToRecordSetRoutingPolicyPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyPtrType) ToRecordSetRoutingPolicyPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPtrOutput)
}

func (i *recordSetRoutingPolicyPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicy] {
	return pulumix.Output[*RecordSetRoutingPolicy]{
		OutputState: i.ToRecordSetRoutingPolicyPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicy)(nil)).Elem()
}

func (o RecordSetRoutingPolicyOutput) ToRecordSetRoutingPolicyOutput() RecordSetRoutingPolicyOutput {
	return o
}

func (o RecordSetRoutingPolicyOutput) ToRecordSetRoutingPolicyOutputWithContext(ctx context.Context) RecordSetRoutingPolicyOutput {
	return o
}

func (o RecordSetRoutingPolicyOutput) ToRecordSetRoutingPolicyPtrOutput() RecordSetRoutingPolicyPtrOutput {
	return o.ToRecordSetRoutingPolicyPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyOutput) ToRecordSetRoutingPolicyPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicy) *RecordSetRoutingPolicy {
		return &v
	}).(RecordSetRoutingPolicyPtrOutput)
}

func (o RecordSetRoutingPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicy] {
	return pulumix.Output[RecordSetRoutingPolicy]{
		OutputState: o.OutputState,
	}
}

// Specifies whether to enable fencing for geo queries.
func (o RecordSetRoutingPolicyOutput) EnableGeoFencing() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicy) *bool { return v.EnableGeoFencing }).(pulumi.BoolPtrOutput)
}

// The configuration for Geolocation based routing policy.
// Structure is document below.
func (o RecordSetRoutingPolicyOutput) Geos() RecordSetRoutingPolicyGeoArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicy) []RecordSetRoutingPolicyGeo { return v.Geos }).(RecordSetRoutingPolicyGeoArrayOutput)
}

// The configuration for a primary-backup policy with global to regional failover. Queries are responded to with the global primary targets, but if none of the primary targets are healthy, then we fallback to a regional failover policy.
// Structure is document below.
func (o RecordSetRoutingPolicyOutput) PrimaryBackup() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicy) *RecordSetRoutingPolicyPrimaryBackup { return v.PrimaryBackup }).(RecordSetRoutingPolicyPrimaryBackupPtrOutput)
}

// The configuration for Weighted Round Robin based routing policy.
// Structure is document below.
func (o RecordSetRoutingPolicyOutput) Wrrs() RecordSetRoutingPolicyWrrArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicy) []RecordSetRoutingPolicyWrr { return v.Wrrs }).(RecordSetRoutingPolicyWrrArrayOutput)
}

type RecordSetRoutingPolicyPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicy)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPtrOutput) ToRecordSetRoutingPolicyPtrOutput() RecordSetRoutingPolicyPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPtrOutput) ToRecordSetRoutingPolicyPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicy] {
	return pulumix.Output[*RecordSetRoutingPolicy]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPtrOutput) Elem() RecordSetRoutingPolicyOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicy) RecordSetRoutingPolicy {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicy
		return ret
	}).(RecordSetRoutingPolicyOutput)
}

// Specifies whether to enable fencing for geo queries.
func (o RecordSetRoutingPolicyPtrOutput) EnableGeoFencing() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicy) *bool {
		if v == nil {
			return nil
		}
		return v.EnableGeoFencing
	}).(pulumi.BoolPtrOutput)
}

// The configuration for Geolocation based routing policy.
// Structure is document below.
func (o RecordSetRoutingPolicyPtrOutput) Geos() RecordSetRoutingPolicyGeoArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicy) []RecordSetRoutingPolicyGeo {
		if v == nil {
			return nil
		}
		return v.Geos
	}).(RecordSetRoutingPolicyGeoArrayOutput)
}

// The configuration for a primary-backup policy with global to regional failover. Queries are responded to with the global primary targets, but if none of the primary targets are healthy, then we fallback to a regional failover policy.
// Structure is document below.
func (o RecordSetRoutingPolicyPtrOutput) PrimaryBackup() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicy) *RecordSetRoutingPolicyPrimaryBackup {
		if v == nil {
			return nil
		}
		return v.PrimaryBackup
	}).(RecordSetRoutingPolicyPrimaryBackupPtrOutput)
}

// The configuration for Weighted Round Robin based routing policy.
// Structure is document below.
func (o RecordSetRoutingPolicyPtrOutput) Wrrs() RecordSetRoutingPolicyWrrArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicy) []RecordSetRoutingPolicyWrr {
		if v == nil {
			return nil
		}
		return v.Wrrs
	}).(RecordSetRoutingPolicyWrrArrayOutput)
}

type RecordSetRoutingPolicyGeo struct {
	// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
	// Structure is document below.
	HealthCheckedTargets *RecordSetRoutingPolicyGeoHealthCheckedTargets `pulumi:"healthCheckedTargets"`
	// The location name defined in Google Cloud.
	Location string `pulumi:"location"`
	// Same as `rrdatas` above.
	Rrdatas []string `pulumi:"rrdatas"`
}

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

	ToRecordSetRoutingPolicyGeoOutput() RecordSetRoutingPolicyGeoOutput
	ToRecordSetRoutingPolicyGeoOutputWithContext(context.Context) RecordSetRoutingPolicyGeoOutput
}

type RecordSetRoutingPolicyGeoArgs struct {
	// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
	// Structure is document below.
	HealthCheckedTargets RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput `pulumi:"healthCheckedTargets"`
	// The location name defined in Google Cloud.
	Location pulumi.StringInput `pulumi:"location"`
	// Same as `rrdatas` above.
	Rrdatas pulumi.StringArrayInput `pulumi:"rrdatas"`
}

func (RecordSetRoutingPolicyGeoArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeo)(nil)).Elem()
}

func (i RecordSetRoutingPolicyGeoArgs) ToRecordSetRoutingPolicyGeoOutput() RecordSetRoutingPolicyGeoOutput {
	return i.ToRecordSetRoutingPolicyGeoOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoArgs) ToRecordSetRoutingPolicyGeoOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoOutput)
}

func (i RecordSetRoutingPolicyGeoArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeo] {
	return pulumix.Output[RecordSetRoutingPolicyGeo]{
		OutputState: i.ToRecordSetRoutingPolicyGeoOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyGeoArrayInput is an input type that accepts RecordSetRoutingPolicyGeoArray and RecordSetRoutingPolicyGeoArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyGeoArrayInput` via:
//
//	RecordSetRoutingPolicyGeoArray{ RecordSetRoutingPolicyGeoArgs{...} }
type RecordSetRoutingPolicyGeoArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyGeoArrayOutput() RecordSetRoutingPolicyGeoArrayOutput
	ToRecordSetRoutingPolicyGeoArrayOutputWithContext(context.Context) RecordSetRoutingPolicyGeoArrayOutput
}

type RecordSetRoutingPolicyGeoArray []RecordSetRoutingPolicyGeoInput

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

func (i RecordSetRoutingPolicyGeoArray) ToRecordSetRoutingPolicyGeoArrayOutput() RecordSetRoutingPolicyGeoArrayOutput {
	return i.ToRecordSetRoutingPolicyGeoArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoArray) ToRecordSetRoutingPolicyGeoArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoArrayOutput)
}

func (i RecordSetRoutingPolicyGeoArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyGeo] {
	return pulumix.Output[[]RecordSetRoutingPolicyGeo]{
		OutputState: i.ToRecordSetRoutingPolicyGeoArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyGeoOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyGeoOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeo)(nil)).Elem()
}

func (o RecordSetRoutingPolicyGeoOutput) ToRecordSetRoutingPolicyGeoOutput() RecordSetRoutingPolicyGeoOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoOutput) ToRecordSetRoutingPolicyGeoOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeo] {
	return pulumix.Output[RecordSetRoutingPolicyGeo]{
		OutputState: o.OutputState,
	}
}

// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
// Structure is document below.
func (o RecordSetRoutingPolicyGeoOutput) HealthCheckedTargets() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeo) *RecordSetRoutingPolicyGeoHealthCheckedTargets {
		return v.HealthCheckedTargets
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput)
}

// The location name defined in Google Cloud.
func (o RecordSetRoutingPolicyGeoOutput) Location() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeo) string { return v.Location }).(pulumi.StringOutput)
}

// Same as `rrdatas` above.
func (o RecordSetRoutingPolicyGeoOutput) Rrdatas() pulumi.StringArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeo) []string { return v.Rrdatas }).(pulumi.StringArrayOutput)
}

type RecordSetRoutingPolicyGeoArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyGeoArrayOutput) ToRecordSetRoutingPolicyGeoArrayOutput() RecordSetRoutingPolicyGeoArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoArrayOutput) ToRecordSetRoutingPolicyGeoArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyGeo] {
	return pulumix.Output[[]RecordSetRoutingPolicyGeo]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyGeoArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyGeoOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyGeo {
		return vs[0].([]RecordSetRoutingPolicyGeo)[vs[1].(int)]
	}).(RecordSetRoutingPolicyGeoOutput)
}

type RecordSetRoutingPolicyGeoHealthCheckedTargets struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers []RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer `pulumi:"internalLoadBalancers"`
}

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

	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput
	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutputWithContext(context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayInput `pulumi:"internalLoadBalancers"`
}

func (RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargets)(nil)).Elem()
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput {
	return i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput)
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput).ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput is an input type that accepts RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs, RecordSetRoutingPolicyGeoHealthCheckedTargetsPtr and RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput` via:
//
//	        RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput
	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput
}

type recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs

func RecordSetRoutingPolicyGeoHealthCheckedTargetsPtr(v *RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput {
	return (*recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType)(v)
}

func (*recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyGeoHealthCheckedTargets)(nil)).Elem()
}

func (i *recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput)
}

func (i *recordSetRoutingPolicyGeoHealthCheckedTargetsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyGeoHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyGeoHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return o.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicyGeoHealthCheckedTargets) *RecordSetRoutingPolicyGeoHealthCheckedTargets {
		return &v
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput)
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput) InternalLoadBalancers() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargets) []RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer {
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyGeoHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyGeoHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyGeoHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) Elem() RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyGeoHealthCheckedTargets) RecordSetRoutingPolicyGeoHealthCheckedTargets {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicyGeoHealthCheckedTargets
		return ret
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput)
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput) InternalLoadBalancers() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyGeoHealthCheckedTargets) []RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer {
		if v == nil {
			return nil
		}
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer struct {
	// The frontend IP address of the load balancer.
	IpAddress string `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol string `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType string `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl string `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port string `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project string `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region *string `pulumi:"region"`
}

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

	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput
	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs struct {
	// The frontend IP address of the load balancer.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol pulumi.StringInput `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType pulumi.StringInput `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port pulumi.StringInput `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project pulumi.StringInput `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

func (RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput)
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayInput is an input type that accepts RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray and RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayInput` via:
//
//	RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray{ RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs{...} }
type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput
	ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray []RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerInput

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

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

func (i RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

// The frontend IP address of the load balancer.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) IpAddress() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string { return v.IpAddress }).(pulumi.StringOutput)
}

// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) IpProtocol() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string { return v.IpProtocol }).(pulumi.StringOutput)
}

// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) LoadBalancerType() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.LoadBalancerType
	}).(pulumi.StringOutput)
}

// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

// The configured port of the load balancer.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string { return v.Port }).(pulumi.StringOutput)
}

// The ID of the project in which the load balancer belongs.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) string { return v.Project }).(pulumi.StringOutput)
}

// The region of the load balancer. Only needed for regional load balancers.
func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput) Region() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer) *string { return v.Region }).(pulumi.StringPtrOutput)
}

type RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer {
		return vs[0].([]RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancer)[vs[1].(int)]
	}).(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput)
}

type RecordSetRoutingPolicyPrimaryBackup struct {
	// The backup geo targets, which provide a regional failover policy for the otherwise global primary targets.
	// Structure is document above.
	BackupGeos []RecordSetRoutingPolicyPrimaryBackupBackupGeo `pulumi:"backupGeos"`
	// Specifies whether to enable fencing for backup geo queries.
	EnableGeoFencingForBackups *bool `pulumi:"enableGeoFencingForBackups"`
	// The list of global primary targets to be health checked.
	// Structure is document below.
	Primary RecordSetRoutingPolicyPrimaryBackupPrimary `pulumi:"primary"`
	// Specifies the percentage of traffic to send to the backup targets even when the primary targets are healthy.
	TrickleRatio *float64 `pulumi:"trickleRatio"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupOutput() RecordSetRoutingPolicyPrimaryBackupOutput
	ToRecordSetRoutingPolicyPrimaryBackupOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupOutput
}

type RecordSetRoutingPolicyPrimaryBackupArgs struct {
	// The backup geo targets, which provide a regional failover policy for the otherwise global primary targets.
	// Structure is document above.
	BackupGeos RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayInput `pulumi:"backupGeos"`
	// Specifies whether to enable fencing for backup geo queries.
	EnableGeoFencingForBackups pulumi.BoolPtrInput `pulumi:"enableGeoFencingForBackups"`
	// The list of global primary targets to be health checked.
	// Structure is document below.
	Primary RecordSetRoutingPolicyPrimaryBackupPrimaryInput `pulumi:"primary"`
	// Specifies the percentage of traffic to send to the backup targets even when the primary targets are healthy.
	TrickleRatio pulumi.Float64PtrInput `pulumi:"trickleRatio"`
}

func (RecordSetRoutingPolicyPrimaryBackupArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackup)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupArgs) ToRecordSetRoutingPolicyPrimaryBackupOutput() RecordSetRoutingPolicyPrimaryBackupOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupArgs) ToRecordSetRoutingPolicyPrimaryBackupOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackup] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackup]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyPrimaryBackupArgs) ToRecordSetRoutingPolicyPrimaryBackupPtrOutput() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupArgs) ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupOutput).ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyPrimaryBackupPtrInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupArgs, RecordSetRoutingPolicyPrimaryBackupPtr and RecordSetRoutingPolicyPrimaryBackupPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupPtrInput` via:
//
//	        RecordSetRoutingPolicyPrimaryBackupArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyPrimaryBackupPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupPtrOutput() RecordSetRoutingPolicyPrimaryBackupPtrOutput
	ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupPtrOutput
}

type recordSetRoutingPolicyPrimaryBackupPtrType RecordSetRoutingPolicyPrimaryBackupArgs

func RecordSetRoutingPolicyPrimaryBackupPtr(v *RecordSetRoutingPolicyPrimaryBackupArgs) RecordSetRoutingPolicyPrimaryBackupPtrInput {
	return (*recordSetRoutingPolicyPrimaryBackupPtrType)(v)
}

func (*recordSetRoutingPolicyPrimaryBackupPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackup)(nil)).Elem()
}

func (i *recordSetRoutingPolicyPrimaryBackupPtrType) ToRecordSetRoutingPolicyPrimaryBackupPtrOutput() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyPrimaryBackupPtrType) ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPtrOutput)
}

func (i *recordSetRoutingPolicyPrimaryBackupPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackup] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackup]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackup)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupOutput) ToRecordSetRoutingPolicyPrimaryBackupOutput() RecordSetRoutingPolicyPrimaryBackupOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupOutput) ToRecordSetRoutingPolicyPrimaryBackupOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupOutput) ToRecordSetRoutingPolicyPrimaryBackupPtrOutput() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o.ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyPrimaryBackupOutput) ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicyPrimaryBackup) *RecordSetRoutingPolicyPrimaryBackup {
		return &v
	}).(RecordSetRoutingPolicyPrimaryBackupPtrOutput)
}

func (o RecordSetRoutingPolicyPrimaryBackupOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackup] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackup]{
		OutputState: o.OutputState,
	}
}

// The backup geo targets, which provide a regional failover policy for the otherwise global primary targets.
// Structure is document above.
func (o RecordSetRoutingPolicyPrimaryBackupOutput) BackupGeos() RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackup) []RecordSetRoutingPolicyPrimaryBackupBackupGeo {
		return v.BackupGeos
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput)
}

// Specifies whether to enable fencing for backup geo queries.
func (o RecordSetRoutingPolicyPrimaryBackupOutput) EnableGeoFencingForBackups() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackup) *bool { return v.EnableGeoFencingForBackups }).(pulumi.BoolPtrOutput)
}

// The list of global primary targets to be health checked.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupOutput) Primary() RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackup) RecordSetRoutingPolicyPrimaryBackupPrimary {
		return v.Primary
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryOutput)
}

// Specifies the percentage of traffic to send to the backup targets even when the primary targets are healthy.
func (o RecordSetRoutingPolicyPrimaryBackupOutput) TrickleRatio() pulumi.Float64PtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackup) *float64 { return v.TrickleRatio }).(pulumi.Float64PtrOutput)
}

type RecordSetRoutingPolicyPrimaryBackupPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackup)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupPtrOutput() RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackup] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackup]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) Elem() RecordSetRoutingPolicyPrimaryBackupOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackup) RecordSetRoutingPolicyPrimaryBackup {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicyPrimaryBackup
		return ret
	}).(RecordSetRoutingPolicyPrimaryBackupOutput)
}

// The backup geo targets, which provide a regional failover policy for the otherwise global primary targets.
// Structure is document above.
func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) BackupGeos() RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackup) []RecordSetRoutingPolicyPrimaryBackupBackupGeo {
		if v == nil {
			return nil
		}
		return v.BackupGeos
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput)
}

// Specifies whether to enable fencing for backup geo queries.
func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) EnableGeoFencingForBackups() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackup) *bool {
		if v == nil {
			return nil
		}
		return v.EnableGeoFencingForBackups
	}).(pulumi.BoolPtrOutput)
}

// The list of global primary targets to be health checked.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) Primary() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackup) *RecordSetRoutingPolicyPrimaryBackupPrimary {
		if v == nil {
			return nil
		}
		return &v.Primary
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput)
}

// Specifies the percentage of traffic to send to the backup targets even when the primary targets are healthy.
func (o RecordSetRoutingPolicyPrimaryBackupPtrOutput) TrickleRatio() pulumi.Float64PtrOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackup) *float64 {
		if v == nil {
			return nil
		}
		return v.TrickleRatio
	}).(pulumi.Float64PtrOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeo struct {
	// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
	// Structure is document below.
	HealthCheckedTargets *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets `pulumi:"healthCheckedTargets"`
	// The location name defined in Google Cloud.
	Location string   `pulumi:"location"`
	Rrdatas  []string `pulumi:"rrdatas"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs struct {
	// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
	// Structure is document below.
	HealthCheckedTargets RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput `pulumi:"healthCheckedTargets"`
	// The location name defined in Google Cloud.
	Location pulumi.StringInput      `pulumi:"location"`
	Rrdatas  pulumi.StringArrayInput `pulumi:"rrdatas"`
}

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeo)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeo] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeo]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupBackupGeoArray and RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayInput` via:
//
//	RecordSetRoutingPolicyPrimaryBackupBackupGeoArray{ RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs{...} }
type RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoArray []RecordSetRoutingPolicyPrimaryBackupBackupGeoInput

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

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArray) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArray) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeo] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeo]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeo)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeo] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeo]{
		OutputState: o.OutputState,
	}
}

// For A and AAAA types only. The list of targets to be health checked. These can be specified along with `rrdatas` within this item.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) HealthCheckedTargets() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeo) *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets {
		return v.HealthCheckedTargets
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput)
}

// The location name defined in Google Cloud.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) Location() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeo) string { return v.Location }).(pulumi.StringOutput)
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput) Rrdatas() pulumi.StringArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeo) []string { return v.Rrdatas }).(pulumi.StringArrayOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeo] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeo]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyPrimaryBackupBackupGeo {
		return vs[0].([]RecordSetRoutingPolicyPrimaryBackupBackupGeo)[vs[1].(int)]
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers []RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer `pulumi:"internalLoadBalancers"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayInput `pulumi:"internalLoadBalancers"`
}

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput).ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs, RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtr and RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput` via:
//
//	        RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput
}

type recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs

func RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtr(v *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput {
	return (*recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType)(v)
}

func (*recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets)(nil)).Elem()
}

func (i *recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput)
}

func (i *recordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return o.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets) *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets {
		return &v
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput)
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput) InternalLoadBalancers() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets) []RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer {
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) Elem() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets
		return ret
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput)
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput) InternalLoadBalancers() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargets) []RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer {
		if v == nil {
			return nil
		}
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer struct {
	// The frontend IP address of the load balancer.
	IpAddress string `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol string `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType string `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl string `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port string `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project string `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region *string `pulumi:"region"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs struct {
	// The frontend IP address of the load balancer.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol pulumi.StringInput `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType pulumi.StringInput `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port pulumi.StringInput `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project pulumi.StringInput `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray and RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayInput` via:
//
//	RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray{ RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs{...} }
type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput
	ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray []RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerInput

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

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

// The frontend IP address of the load balancer.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) IpAddress() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.IpAddress
	}).(pulumi.StringOutput)
}

// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) IpProtocol() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.IpProtocol
	}).(pulumi.StringOutput)
}

// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) LoadBalancerType() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.LoadBalancerType
	}).(pulumi.StringOutput)
}

// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.NetworkUrl
	}).(pulumi.StringOutput)
}

// The configured port of the load balancer.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.Port
	}).(pulumi.StringOutput)
}

// The ID of the project in which the load balancer belongs.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) string {
		return v.Project
	}).(pulumi.StringOutput)
}

// The region of the load balancer. Only needed for regional load balancers.
func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput) Region() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer) *string {
		return v.Region
	}).(pulumi.StringPtrOutput)
}

type RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer {
		return vs[0].([]RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancer)[vs[1].(int)]
	}).(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput)
}

type RecordSetRoutingPolicyPrimaryBackupPrimary struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers []RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer `pulumi:"internalLoadBalancers"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryOutput
	ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryOutput
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryArgs struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayInput `pulumi:"internalLoadBalancers"`
}

func (RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimary)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPrimaryOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimary] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimary]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPrimaryOutput).ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyPrimaryBackupPrimaryPtrInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupPrimaryArgs, RecordSetRoutingPolicyPrimaryBackupPrimaryPtr and RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupPrimaryPtrInput` via:
//
//	        RecordSetRoutingPolicyPrimaryBackupPrimaryArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyPrimaryBackupPrimaryPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput
	ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput
}

type recordSetRoutingPolicyPrimaryBackupPrimaryPtrType RecordSetRoutingPolicyPrimaryBackupPrimaryArgs

func RecordSetRoutingPolicyPrimaryBackupPrimaryPtr(v *RecordSetRoutingPolicyPrimaryBackupPrimaryArgs) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrInput {
	return (*recordSetRoutingPolicyPrimaryBackupPrimaryPtrType)(v)
}

func (*recordSetRoutingPolicyPrimaryBackupPrimaryPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackupPrimary)(nil)).Elem()
}

func (i *recordSetRoutingPolicyPrimaryBackupPrimaryPtrType) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyPrimaryBackupPrimaryPtrType) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput)
}

func (i *recordSetRoutingPolicyPrimaryBackupPrimaryPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupPrimary] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupPrimary]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimary)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return o.ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicyPrimaryBackupPrimary) *RecordSetRoutingPolicyPrimaryBackupPrimary {
		return &v
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput)
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimary] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimary]{
		OutputState: o.OutputState,
	}
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryOutput) InternalLoadBalancers() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimary) []RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer {
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyPrimaryBackupPrimary)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupPrimary] {
	return pulumix.Output[*RecordSetRoutingPolicyPrimaryBackupPrimary]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) Elem() RecordSetRoutingPolicyPrimaryBackupPrimaryOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackupPrimary) RecordSetRoutingPolicyPrimaryBackupPrimary {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicyPrimaryBackupPrimary
		return ret
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryOutput)
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput) InternalLoadBalancers() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyPrimaryBackupPrimary) []RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer {
		if v == nil {
			return nil
		}
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer struct {
	// The frontend IP address of the load balancer.
	IpAddress string `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol string `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType string `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl string `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port string `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project string `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region *string `pulumi:"region"`
}

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

	ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput
	ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs struct {
	// The frontend IP address of the load balancer.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol pulumi.StringInput `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType pulumi.StringInput `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port pulumi.StringInput `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project pulumi.StringInput `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

func (RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer)(nil)).Elem()
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayInput is an input type that accepts RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray and RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayInput` via:
//
//	RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray{ RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs{...} }
type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput
	ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutputWithContext(context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray []RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerInput

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

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput)
}

func (i RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer)(nil)).Elem()
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

// The frontend IP address of the load balancer.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) IpAddress() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string { return v.IpAddress }).(pulumi.StringOutput)
}

// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) IpProtocol() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string { return v.IpProtocol }).(pulumi.StringOutput)
}

// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) LoadBalancerType() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string {
		return v.LoadBalancerType
	}).(pulumi.StringOutput)
}

// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

// The configured port of the load balancer.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string { return v.Port }).(pulumi.StringOutput)
}

// The ID of the project in which the load balancer belongs.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) string { return v.Project }).(pulumi.StringOutput)
}

// The region of the load balancer. Only needed for regional load balancers.
func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput) Region() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer) *string { return v.Region }).(pulumi.StringPtrOutput)
}

type RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer {
		return vs[0].([]RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancer)[vs[1].(int)]
	}).(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput)
}

type RecordSetRoutingPolicyWrr struct {
	// The list of targets to be health checked. Note that if DNSSEC is enabled for this zone, only one of `rrdatas` or `healthCheckedTargets` can be set.
	// Structure is document below.
	HealthCheckedTargets *RecordSetRoutingPolicyWrrHealthCheckedTargets `pulumi:"healthCheckedTargets"`
	// Same as `rrdatas` above.
	Rrdatas []string `pulumi:"rrdatas"`
	// The ratio of traffic routed to the target.
	Weight float64 `pulumi:"weight"`
}

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

	ToRecordSetRoutingPolicyWrrOutput() RecordSetRoutingPolicyWrrOutput
	ToRecordSetRoutingPolicyWrrOutputWithContext(context.Context) RecordSetRoutingPolicyWrrOutput
}

type RecordSetRoutingPolicyWrrArgs struct {
	// The list of targets to be health checked. Note that if DNSSEC is enabled for this zone, only one of `rrdatas` or `healthCheckedTargets` can be set.
	// Structure is document below.
	HealthCheckedTargets RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput `pulumi:"healthCheckedTargets"`
	// Same as `rrdatas` above.
	Rrdatas pulumi.StringArrayInput `pulumi:"rrdatas"`
	// The ratio of traffic routed to the target.
	Weight pulumi.Float64Input `pulumi:"weight"`
}

func (RecordSetRoutingPolicyWrrArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrr)(nil)).Elem()
}

func (i RecordSetRoutingPolicyWrrArgs) ToRecordSetRoutingPolicyWrrOutput() RecordSetRoutingPolicyWrrOutput {
	return i.ToRecordSetRoutingPolicyWrrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrArgs) ToRecordSetRoutingPolicyWrrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrOutput)
}

func (i RecordSetRoutingPolicyWrrArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrr] {
	return pulumix.Output[RecordSetRoutingPolicyWrr]{
		OutputState: i.ToRecordSetRoutingPolicyWrrOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyWrrArrayInput is an input type that accepts RecordSetRoutingPolicyWrrArray and RecordSetRoutingPolicyWrrArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyWrrArrayInput` via:
//
//	RecordSetRoutingPolicyWrrArray{ RecordSetRoutingPolicyWrrArgs{...} }
type RecordSetRoutingPolicyWrrArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyWrrArrayOutput() RecordSetRoutingPolicyWrrArrayOutput
	ToRecordSetRoutingPolicyWrrArrayOutputWithContext(context.Context) RecordSetRoutingPolicyWrrArrayOutput
}

type RecordSetRoutingPolicyWrrArray []RecordSetRoutingPolicyWrrInput

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

func (i RecordSetRoutingPolicyWrrArray) ToRecordSetRoutingPolicyWrrArrayOutput() RecordSetRoutingPolicyWrrArrayOutput {
	return i.ToRecordSetRoutingPolicyWrrArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrArray) ToRecordSetRoutingPolicyWrrArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrArrayOutput)
}

func (i RecordSetRoutingPolicyWrrArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyWrr] {
	return pulumix.Output[[]RecordSetRoutingPolicyWrr]{
		OutputState: i.ToRecordSetRoutingPolicyWrrArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyWrrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyWrrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrr)(nil)).Elem()
}

func (o RecordSetRoutingPolicyWrrOutput) ToRecordSetRoutingPolicyWrrOutput() RecordSetRoutingPolicyWrrOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrOutput) ToRecordSetRoutingPolicyWrrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrr] {
	return pulumix.Output[RecordSetRoutingPolicyWrr]{
		OutputState: o.OutputState,
	}
}

// The list of targets to be health checked. Note that if DNSSEC is enabled for this zone, only one of `rrdatas` or `healthCheckedTargets` can be set.
// Structure is document below.
func (o RecordSetRoutingPolicyWrrOutput) HealthCheckedTargets() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrr) *RecordSetRoutingPolicyWrrHealthCheckedTargets {
		return v.HealthCheckedTargets
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput)
}

// Same as `rrdatas` above.
func (o RecordSetRoutingPolicyWrrOutput) Rrdatas() pulumi.StringArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrr) []string { return v.Rrdatas }).(pulumi.StringArrayOutput)
}

// The ratio of traffic routed to the target.
func (o RecordSetRoutingPolicyWrrOutput) Weight() pulumi.Float64Output {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrr) float64 { return v.Weight }).(pulumi.Float64Output)
}

type RecordSetRoutingPolicyWrrArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyWrrArrayOutput) ToRecordSetRoutingPolicyWrrArrayOutput() RecordSetRoutingPolicyWrrArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrArrayOutput) ToRecordSetRoutingPolicyWrrArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyWrr] {
	return pulumix.Output[[]RecordSetRoutingPolicyWrr]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyWrrArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyWrrOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyWrr {
		return vs[0].([]RecordSetRoutingPolicyWrr)[vs[1].(int)]
	}).(RecordSetRoutingPolicyWrrOutput)
}

type RecordSetRoutingPolicyWrrHealthCheckedTargets struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers []RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer `pulumi:"internalLoadBalancers"`
}

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

	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput
	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutputWithContext(context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs struct {
	// The list of internal load balancers to health check.
	// Structure is document below.
	InternalLoadBalancers RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayInput `pulumi:"internalLoadBalancers"`
}

func (RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargets)(nil)).Elem()
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput {
	return i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput)
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutputWithContext(ctx).OutputState,
	}
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput).ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx)
}

// RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput is an input type that accepts RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs, RecordSetRoutingPolicyWrrHealthCheckedTargetsPtr and RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput` via:
//
//	        RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs{...}
//
//	or:
//
//	        nil
type RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput
	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput
}

type recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs

func RecordSetRoutingPolicyWrrHealthCheckedTargetsPtr(v *RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput {
	return (*recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType)(v)
}

func (*recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyWrrHealthCheckedTargets)(nil)).Elem()
}

func (i *recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (i *recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput)
}

func (i *recordSetRoutingPolicyWrrHealthCheckedTargetsPtrType) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyWrrHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyWrrHealthCheckedTargets]{
		OutputState: i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return o.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(context.Background())
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RecordSetRoutingPolicyWrrHealthCheckedTargets) *RecordSetRoutingPolicyWrrHealthCheckedTargets {
		return &v
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput)
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargets] {
	return pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput) InternalLoadBalancers() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargets) []RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer {
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RecordSetRoutingPolicyWrrHealthCheckedTargets)(nil)).Elem()
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*RecordSetRoutingPolicyWrrHealthCheckedTargets] {
	return pulumix.Output[*RecordSetRoutingPolicyWrrHealthCheckedTargets]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) Elem() RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyWrrHealthCheckedTargets) RecordSetRoutingPolicyWrrHealthCheckedTargets {
		if v != nil {
			return *v
		}
		var ret RecordSetRoutingPolicyWrrHealthCheckedTargets
		return ret
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput)
}

// The list of internal load balancers to health check.
// Structure is document below.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput) InternalLoadBalancers() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o.ApplyT(func(v *RecordSetRoutingPolicyWrrHealthCheckedTargets) []RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer {
		if v == nil {
			return nil
		}
		return v.InternalLoadBalancers
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer struct {
	// The frontend IP address of the load balancer.
	IpAddress string `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol string `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType string `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl string `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port string `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project string `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region *string `pulumi:"region"`
}

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

	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput
	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs struct {
	// The frontend IP address of the load balancer.
	IpAddress pulumi.StringInput `pulumi:"ipAddress"`
	// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
	IpProtocol pulumi.StringInput `pulumi:"ipProtocol"`
	// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
	LoadBalancerType pulumi.StringInput `pulumi:"loadBalancerType"`
	// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
	// The configured port of the load balancer.
	Port pulumi.StringInput `pulumi:"port"`
	// The ID of the project in which the load balancer belongs.
	Project pulumi.StringInput `pulumi:"project"`
	// The region of the load balancer. Only needed for regional load balancers.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

func (RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput {
	return i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput)
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx).OutputState,
	}
}

// RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayInput is an input type that accepts RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray and RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput values.
// You can construct a concrete instance of `RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayInput` via:
//
//	RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray{ RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs{...} }
type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayInput interface {
	pulumi.Input

	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput
	ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray []RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerInput

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

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(context.Background())
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput)
}

func (i RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: i.ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx).OutputState,
	}
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput struct{ *pulumi.OutputState }

func (RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer)(nil)).Elem()
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) ToOutput(ctx context.Context) pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

// The frontend IP address of the load balancer.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) IpAddress() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string { return v.IpAddress }).(pulumi.StringOutput)
}

// The configured IP protocol of the load balancer. This value is case-sensitive. Possible values: ["tcp", "udp"]
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) IpProtocol() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string { return v.IpProtocol }).(pulumi.StringOutput)
}

// The type of load balancer. This value is case-sensitive. Possible values: ["regionalL4ilb", "regionalL7ilb", "globalL7ilb"]
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) LoadBalancerType() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string {
		return v.LoadBalancerType
	}).(pulumi.StringOutput)
}

// The fully qualified url of the network in which the load balancer belongs. This should be formatted like `projects/{project}/global/networks/{network}` or `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

// The configured port of the load balancer.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) Port() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string { return v.Port }).(pulumi.StringOutput)
}

// The ID of the project in which the load balancer belongs.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) Project() pulumi.StringOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) string { return v.Project }).(pulumi.StringOutput)
}

// The region of the load balancer. Only needed for regional load balancers.
func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput) Region() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer) *string { return v.Region }).(pulumi.StringPtrOutput)
}

type RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput struct{ *pulumi.OutputState }

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

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput() RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToRecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutputWithContext(ctx context.Context) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput {
	return o
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer] {
	return pulumix.Output[[]RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer]{
		OutputState: o.OutputState,
	}
}

func (o RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput) Index(i pulumi.IntInput) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer {
		return vs[0].([]RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancer)[vs[1].(int)]
	}).(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput)
}

type ResponsePolicyGkeCluster struct {
	// The resource name of the cluster to bind this ManagedZone to.
	// This should be specified in the format like
	// `projects/*/locations/*/clusters/*`
	GkeClusterName string `pulumi:"gkeClusterName"`
}

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

	ToResponsePolicyGkeClusterOutput() ResponsePolicyGkeClusterOutput
	ToResponsePolicyGkeClusterOutputWithContext(context.Context) ResponsePolicyGkeClusterOutput
}

type ResponsePolicyGkeClusterArgs struct {
	// The resource name of the cluster to bind this ManagedZone to.
	// This should be specified in the format like
	// `projects/*/locations/*/clusters/*`
	GkeClusterName pulumi.StringInput `pulumi:"gkeClusterName"`
}

func (ResponsePolicyGkeClusterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyGkeCluster)(nil)).Elem()
}

func (i ResponsePolicyGkeClusterArgs) ToResponsePolicyGkeClusterOutput() ResponsePolicyGkeClusterOutput {
	return i.ToResponsePolicyGkeClusterOutputWithContext(context.Background())
}

func (i ResponsePolicyGkeClusterArgs) ToResponsePolicyGkeClusterOutputWithContext(ctx context.Context) ResponsePolicyGkeClusterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyGkeClusterOutput)
}

func (i ResponsePolicyGkeClusterArgs) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyGkeCluster] {
	return pulumix.Output[ResponsePolicyGkeCluster]{
		OutputState: i.ToResponsePolicyGkeClusterOutputWithContext(ctx).OutputState,
	}
}

// ResponsePolicyGkeClusterArrayInput is an input type that accepts ResponsePolicyGkeClusterArray and ResponsePolicyGkeClusterArrayOutput values.
// You can construct a concrete instance of `ResponsePolicyGkeClusterArrayInput` via:
//
//	ResponsePolicyGkeClusterArray{ ResponsePolicyGkeClusterArgs{...} }
type ResponsePolicyGkeClusterArrayInput interface {
	pulumi.Input

	ToResponsePolicyGkeClusterArrayOutput() ResponsePolicyGkeClusterArrayOutput
	ToResponsePolicyGkeClusterArrayOutputWithContext(context.Context) ResponsePolicyGkeClusterArrayOutput
}

type ResponsePolicyGkeClusterArray []ResponsePolicyGkeClusterInput

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

func (i ResponsePolicyGkeClusterArray) ToResponsePolicyGkeClusterArrayOutput() ResponsePolicyGkeClusterArrayOutput {
	return i.ToResponsePolicyGkeClusterArrayOutputWithContext(context.Background())
}

func (i ResponsePolicyGkeClusterArray) ToResponsePolicyGkeClusterArrayOutputWithContext(ctx context.Context) ResponsePolicyGkeClusterArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyGkeClusterArrayOutput)
}

func (i ResponsePolicyGkeClusterArray) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyGkeCluster] {
	return pulumix.Output[[]ResponsePolicyGkeCluster]{
		OutputState: i.ToResponsePolicyGkeClusterArrayOutputWithContext(ctx).OutputState,
	}
}

type ResponsePolicyGkeClusterOutput struct{ *pulumi.OutputState }

func (ResponsePolicyGkeClusterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyGkeCluster)(nil)).Elem()
}

func (o ResponsePolicyGkeClusterOutput) ToResponsePolicyGkeClusterOutput() ResponsePolicyGkeClusterOutput {
	return o
}

func (o ResponsePolicyGkeClusterOutput) ToResponsePolicyGkeClusterOutputWithContext(ctx context.Context) ResponsePolicyGkeClusterOutput {
	return o
}

func (o ResponsePolicyGkeClusterOutput) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyGkeCluster] {
	return pulumix.Output[ResponsePolicyGkeCluster]{
		OutputState: o.OutputState,
	}
}

// The resource name of the cluster to bind this ManagedZone to.
// This should be specified in the format like
// `projects/*/locations/*/clusters/*`
func (o ResponsePolicyGkeClusterOutput) GkeClusterName() pulumi.StringOutput {
	return o.ApplyT(func(v ResponsePolicyGkeCluster) string { return v.GkeClusterName }).(pulumi.StringOutput)
}

type ResponsePolicyGkeClusterArrayOutput struct{ *pulumi.OutputState }

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

func (o ResponsePolicyGkeClusterArrayOutput) ToResponsePolicyGkeClusterArrayOutput() ResponsePolicyGkeClusterArrayOutput {
	return o
}

func (o ResponsePolicyGkeClusterArrayOutput) ToResponsePolicyGkeClusterArrayOutputWithContext(ctx context.Context) ResponsePolicyGkeClusterArrayOutput {
	return o
}

func (o ResponsePolicyGkeClusterArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyGkeCluster] {
	return pulumix.Output[[]ResponsePolicyGkeCluster]{
		OutputState: o.OutputState,
	}
}

func (o ResponsePolicyGkeClusterArrayOutput) Index(i pulumi.IntInput) ResponsePolicyGkeClusterOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResponsePolicyGkeCluster {
		return vs[0].([]ResponsePolicyGkeCluster)[vs[1].(int)]
	}).(ResponsePolicyGkeClusterOutput)
}

type ResponsePolicyNetwork struct {
	// The fully qualified URL of the VPC network to bind to.
	// This should be formatted like
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl string `pulumi:"networkUrl"`
}

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

	ToResponsePolicyNetworkOutput() ResponsePolicyNetworkOutput
	ToResponsePolicyNetworkOutputWithContext(context.Context) ResponsePolicyNetworkOutput
}

type ResponsePolicyNetworkArgs struct {
	// The fully qualified URL of the VPC network to bind to.
	// This should be formatted like
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
	NetworkUrl pulumi.StringInput `pulumi:"networkUrl"`
}

func (ResponsePolicyNetworkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyNetwork)(nil)).Elem()
}

func (i ResponsePolicyNetworkArgs) ToResponsePolicyNetworkOutput() ResponsePolicyNetworkOutput {
	return i.ToResponsePolicyNetworkOutputWithContext(context.Background())
}

func (i ResponsePolicyNetworkArgs) ToResponsePolicyNetworkOutputWithContext(ctx context.Context) ResponsePolicyNetworkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyNetworkOutput)
}

func (i ResponsePolicyNetworkArgs) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyNetwork] {
	return pulumix.Output[ResponsePolicyNetwork]{
		OutputState: i.ToResponsePolicyNetworkOutputWithContext(ctx).OutputState,
	}
}

// ResponsePolicyNetworkArrayInput is an input type that accepts ResponsePolicyNetworkArray and ResponsePolicyNetworkArrayOutput values.
// You can construct a concrete instance of `ResponsePolicyNetworkArrayInput` via:
//
//	ResponsePolicyNetworkArray{ ResponsePolicyNetworkArgs{...} }
type ResponsePolicyNetworkArrayInput interface {
	pulumi.Input

	ToResponsePolicyNetworkArrayOutput() ResponsePolicyNetworkArrayOutput
	ToResponsePolicyNetworkArrayOutputWithContext(context.Context) ResponsePolicyNetworkArrayOutput
}

type ResponsePolicyNetworkArray []ResponsePolicyNetworkInput

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

func (i ResponsePolicyNetworkArray) ToResponsePolicyNetworkArrayOutput() ResponsePolicyNetworkArrayOutput {
	return i.ToResponsePolicyNetworkArrayOutputWithContext(context.Background())
}

func (i ResponsePolicyNetworkArray) ToResponsePolicyNetworkArrayOutputWithContext(ctx context.Context) ResponsePolicyNetworkArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyNetworkArrayOutput)
}

func (i ResponsePolicyNetworkArray) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyNetwork] {
	return pulumix.Output[[]ResponsePolicyNetwork]{
		OutputState: i.ToResponsePolicyNetworkArrayOutputWithContext(ctx).OutputState,
	}
}

type ResponsePolicyNetworkOutput struct{ *pulumi.OutputState }

func (ResponsePolicyNetworkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyNetwork)(nil)).Elem()
}

func (o ResponsePolicyNetworkOutput) ToResponsePolicyNetworkOutput() ResponsePolicyNetworkOutput {
	return o
}

func (o ResponsePolicyNetworkOutput) ToResponsePolicyNetworkOutputWithContext(ctx context.Context) ResponsePolicyNetworkOutput {
	return o
}

func (o ResponsePolicyNetworkOutput) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyNetwork] {
	return pulumix.Output[ResponsePolicyNetwork]{
		OutputState: o.OutputState,
	}
}

// The fully qualified URL of the VPC network to bind to.
// This should be formatted like
// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{network}`
func (o ResponsePolicyNetworkOutput) NetworkUrl() pulumi.StringOutput {
	return o.ApplyT(func(v ResponsePolicyNetwork) string { return v.NetworkUrl }).(pulumi.StringOutput)
}

type ResponsePolicyNetworkArrayOutput struct{ *pulumi.OutputState }

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

func (o ResponsePolicyNetworkArrayOutput) ToResponsePolicyNetworkArrayOutput() ResponsePolicyNetworkArrayOutput {
	return o
}

func (o ResponsePolicyNetworkArrayOutput) ToResponsePolicyNetworkArrayOutputWithContext(ctx context.Context) ResponsePolicyNetworkArrayOutput {
	return o
}

func (o ResponsePolicyNetworkArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyNetwork] {
	return pulumix.Output[[]ResponsePolicyNetwork]{
		OutputState: o.OutputState,
	}
}

func (o ResponsePolicyNetworkArrayOutput) Index(i pulumi.IntInput) ResponsePolicyNetworkOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResponsePolicyNetwork {
		return vs[0].([]ResponsePolicyNetwork)[vs[1].(int)]
	}).(ResponsePolicyNetworkOutput)
}

type ResponsePolicyRuleLocalData struct {
	// All resource record sets for this selector, one per resource record type. The name must match the dns_name.
	// Structure is documented below.
	LocalDatas []ResponsePolicyRuleLocalDataLocalData `pulumi:"localDatas"`
}

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

	ToResponsePolicyRuleLocalDataOutput() ResponsePolicyRuleLocalDataOutput
	ToResponsePolicyRuleLocalDataOutputWithContext(context.Context) ResponsePolicyRuleLocalDataOutput
}

type ResponsePolicyRuleLocalDataArgs struct {
	// All resource record sets for this selector, one per resource record type. The name must match the dns_name.
	// Structure is documented below.
	LocalDatas ResponsePolicyRuleLocalDataLocalDataArrayInput `pulumi:"localDatas"`
}

func (ResponsePolicyRuleLocalDataArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyRuleLocalData)(nil)).Elem()
}

func (i ResponsePolicyRuleLocalDataArgs) ToResponsePolicyRuleLocalDataOutput() ResponsePolicyRuleLocalDataOutput {
	return i.ToResponsePolicyRuleLocalDataOutputWithContext(context.Background())
}

func (i ResponsePolicyRuleLocalDataArgs) ToResponsePolicyRuleLocalDataOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyRuleLocalDataOutput)
}

func (i ResponsePolicyRuleLocalDataArgs) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyRuleLocalData] {
	return pulumix.Output[ResponsePolicyRuleLocalData]{
		OutputState: i.ToResponsePolicyRuleLocalDataOutputWithContext(ctx).OutputState,
	}
}

func (i ResponsePolicyRuleLocalDataArgs) ToResponsePolicyRuleLocalDataPtrOutput() ResponsePolicyRuleLocalDataPtrOutput {
	return i.ToResponsePolicyRuleLocalDataPtrOutputWithContext(context.Background())
}

func (i ResponsePolicyRuleLocalDataArgs) ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyRuleLocalDataOutput).ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx)
}

// ResponsePolicyRuleLocalDataPtrInput is an input type that accepts ResponsePolicyRuleLocalDataArgs, ResponsePolicyRuleLocalDataPtr and ResponsePolicyRuleLocalDataPtrOutput values.
// You can construct a concrete instance of `ResponsePolicyRuleLocalDataPtrInput` via:
//
//	        ResponsePolicyRuleLocalDataArgs{...}
//
//	or:
//
//	        nil
type ResponsePolicyRuleLocalDataPtrInput interface {
	pulumi.Input

	ToResponsePolicyRuleLocalDataPtrOutput() ResponsePolicyRuleLocalDataPtrOutput
	ToResponsePolicyRuleLocalDataPtrOutputWithContext(context.Context) ResponsePolicyRuleLocalDataPtrOutput
}

type responsePolicyRuleLocalDataPtrType ResponsePolicyRuleLocalDataArgs

func ResponsePolicyRuleLocalDataPtr(v *ResponsePolicyRuleLocalDataArgs) ResponsePolicyRuleLocalDataPtrInput {
	return (*responsePolicyRuleLocalDataPtrType)(v)
}

func (*responsePolicyRuleLocalDataPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResponsePolicyRuleLocalData)(nil)).Elem()
}

func (i *responsePolicyRuleLocalDataPtrType) ToResponsePolicyRuleLocalDataPtrOutput() ResponsePolicyRuleLocalDataPtrOutput {
	return i.ToResponsePolicyRuleLocalDataPtrOutputWithContext(context.Background())
}

func (i *responsePolicyRuleLocalDataPtrType) ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyRuleLocalDataPtrOutput)
}

func (i *responsePolicyRuleLocalDataPtrType) ToOutput(ctx context.Context) pulumix.Output[*ResponsePolicyRuleLocalData] {
	return pulumix.Output[*ResponsePolicyRuleLocalData]{
		OutputState: i.ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx).OutputState,
	}
}

type ResponsePolicyRuleLocalDataOutput struct{ *pulumi.OutputState }

func (ResponsePolicyRuleLocalDataOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyRuleLocalData)(nil)).Elem()
}

func (o ResponsePolicyRuleLocalDataOutput) ToResponsePolicyRuleLocalDataOutput() ResponsePolicyRuleLocalDataOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataOutput) ToResponsePolicyRuleLocalDataOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataOutput) ToResponsePolicyRuleLocalDataPtrOutput() ResponsePolicyRuleLocalDataPtrOutput {
	return o.ToResponsePolicyRuleLocalDataPtrOutputWithContext(context.Background())
}

func (o ResponsePolicyRuleLocalDataOutput) ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResponsePolicyRuleLocalData) *ResponsePolicyRuleLocalData {
		return &v
	}).(ResponsePolicyRuleLocalDataPtrOutput)
}

func (o ResponsePolicyRuleLocalDataOutput) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyRuleLocalData] {
	return pulumix.Output[ResponsePolicyRuleLocalData]{
		OutputState: o.OutputState,
	}
}

// All resource record sets for this selector, one per resource record type. The name must match the dns_name.
// Structure is documented below.
func (o ResponsePolicyRuleLocalDataOutput) LocalDatas() ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return o.ApplyT(func(v ResponsePolicyRuleLocalData) []ResponsePolicyRuleLocalDataLocalData { return v.LocalDatas }).(ResponsePolicyRuleLocalDataLocalDataArrayOutput)
}

type ResponsePolicyRuleLocalDataPtrOutput struct{ *pulumi.OutputState }

func (ResponsePolicyRuleLocalDataPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResponsePolicyRuleLocalData)(nil)).Elem()
}

func (o ResponsePolicyRuleLocalDataPtrOutput) ToResponsePolicyRuleLocalDataPtrOutput() ResponsePolicyRuleLocalDataPtrOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataPtrOutput) ToResponsePolicyRuleLocalDataPtrOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataPtrOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ResponsePolicyRuleLocalData] {
	return pulumix.Output[*ResponsePolicyRuleLocalData]{
		OutputState: o.OutputState,
	}
}

func (o ResponsePolicyRuleLocalDataPtrOutput) Elem() ResponsePolicyRuleLocalDataOutput {
	return o.ApplyT(func(v *ResponsePolicyRuleLocalData) ResponsePolicyRuleLocalData {
		if v != nil {
			return *v
		}
		var ret ResponsePolicyRuleLocalData
		return ret
	}).(ResponsePolicyRuleLocalDataOutput)
}

// All resource record sets for this selector, one per resource record type. The name must match the dns_name.
// Structure is documented below.
func (o ResponsePolicyRuleLocalDataPtrOutput) LocalDatas() ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return o.ApplyT(func(v *ResponsePolicyRuleLocalData) []ResponsePolicyRuleLocalDataLocalData {
		if v == nil {
			return nil
		}
		return v.LocalDatas
	}).(ResponsePolicyRuleLocalDataLocalDataArrayOutput)
}

type ResponsePolicyRuleLocalDataLocalData struct {
	// For example, www.example.com.
	Name string `pulumi:"name"`
	// As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1)
	Rrdatas []string `pulumi:"rrdatas"`
	// Number of seconds that this ResourceRecordSet can be cached by
	// resolvers.
	Ttl *int `pulumi:"ttl"`
	// One of valid DNS resource types.
	// Possible values are: `A`, `AAAA`, `CAA`, `CNAME`, `DNSKEY`, `DS`, `HTTPS`, `IPSECVPNKEY`, `MX`, `NAPTR`, `NS`, `PTR`, `SOA`, `SPF`, `SRV`, `SSHFP`, `SVCB`, `TLSA`, `TXT`.
	Type string `pulumi:"type"`
}

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

	ToResponsePolicyRuleLocalDataLocalDataOutput() ResponsePolicyRuleLocalDataLocalDataOutput
	ToResponsePolicyRuleLocalDataLocalDataOutputWithContext(context.Context) ResponsePolicyRuleLocalDataLocalDataOutput
}

type ResponsePolicyRuleLocalDataLocalDataArgs struct {
	// For example, www.example.com.
	Name pulumi.StringInput `pulumi:"name"`
	// As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1)
	Rrdatas pulumi.StringArrayInput `pulumi:"rrdatas"`
	// Number of seconds that this ResourceRecordSet can be cached by
	// resolvers.
	Ttl pulumi.IntPtrInput `pulumi:"ttl"`
	// One of valid DNS resource types.
	// Possible values are: `A`, `AAAA`, `CAA`, `CNAME`, `DNSKEY`, `DS`, `HTTPS`, `IPSECVPNKEY`, `MX`, `NAPTR`, `NS`, `PTR`, `SOA`, `SPF`, `SRV`, `SSHFP`, `SVCB`, `TLSA`, `TXT`.
	Type pulumi.StringInput `pulumi:"type"`
}

func (ResponsePolicyRuleLocalDataLocalDataArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyRuleLocalDataLocalData)(nil)).Elem()
}

func (i ResponsePolicyRuleLocalDataLocalDataArgs) ToResponsePolicyRuleLocalDataLocalDataOutput() ResponsePolicyRuleLocalDataLocalDataOutput {
	return i.ToResponsePolicyRuleLocalDataLocalDataOutputWithContext(context.Background())
}

func (i ResponsePolicyRuleLocalDataLocalDataArgs) ToResponsePolicyRuleLocalDataLocalDataOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataLocalDataOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyRuleLocalDataLocalDataOutput)
}

func (i ResponsePolicyRuleLocalDataLocalDataArgs) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyRuleLocalDataLocalData] {
	return pulumix.Output[ResponsePolicyRuleLocalDataLocalData]{
		OutputState: i.ToResponsePolicyRuleLocalDataLocalDataOutputWithContext(ctx).OutputState,
	}
}

// ResponsePolicyRuleLocalDataLocalDataArrayInput is an input type that accepts ResponsePolicyRuleLocalDataLocalDataArray and ResponsePolicyRuleLocalDataLocalDataArrayOutput values.
// You can construct a concrete instance of `ResponsePolicyRuleLocalDataLocalDataArrayInput` via:
//
//	ResponsePolicyRuleLocalDataLocalDataArray{ ResponsePolicyRuleLocalDataLocalDataArgs{...} }
type ResponsePolicyRuleLocalDataLocalDataArrayInput interface {
	pulumi.Input

	ToResponsePolicyRuleLocalDataLocalDataArrayOutput() ResponsePolicyRuleLocalDataLocalDataArrayOutput
	ToResponsePolicyRuleLocalDataLocalDataArrayOutputWithContext(context.Context) ResponsePolicyRuleLocalDataLocalDataArrayOutput
}

type ResponsePolicyRuleLocalDataLocalDataArray []ResponsePolicyRuleLocalDataLocalDataInput

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

func (i ResponsePolicyRuleLocalDataLocalDataArray) ToResponsePolicyRuleLocalDataLocalDataArrayOutput() ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return i.ToResponsePolicyRuleLocalDataLocalDataArrayOutputWithContext(context.Background())
}

func (i ResponsePolicyRuleLocalDataLocalDataArray) ToResponsePolicyRuleLocalDataLocalDataArrayOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResponsePolicyRuleLocalDataLocalDataArrayOutput)
}

func (i ResponsePolicyRuleLocalDataLocalDataArray) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyRuleLocalDataLocalData] {
	return pulumix.Output[[]ResponsePolicyRuleLocalDataLocalData]{
		OutputState: i.ToResponsePolicyRuleLocalDataLocalDataArrayOutputWithContext(ctx).OutputState,
	}
}

type ResponsePolicyRuleLocalDataLocalDataOutput struct{ *pulumi.OutputState }

func (ResponsePolicyRuleLocalDataLocalDataOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResponsePolicyRuleLocalDataLocalData)(nil)).Elem()
}

func (o ResponsePolicyRuleLocalDataLocalDataOutput) ToResponsePolicyRuleLocalDataLocalDataOutput() ResponsePolicyRuleLocalDataLocalDataOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataLocalDataOutput) ToResponsePolicyRuleLocalDataLocalDataOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataLocalDataOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataLocalDataOutput) ToOutput(ctx context.Context) pulumix.Output[ResponsePolicyRuleLocalDataLocalData] {
	return pulumix.Output[ResponsePolicyRuleLocalDataLocalData]{
		OutputState: o.OutputState,
	}
}

// For example, www.example.com.
func (o ResponsePolicyRuleLocalDataLocalDataOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResponsePolicyRuleLocalDataLocalData) string { return v.Name }).(pulumi.StringOutput)
}

// As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1)
func (o ResponsePolicyRuleLocalDataLocalDataOutput) Rrdatas() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ResponsePolicyRuleLocalDataLocalData) []string { return v.Rrdatas }).(pulumi.StringArrayOutput)
}

// Number of seconds that this ResourceRecordSet can be cached by
// resolvers.
func (o ResponsePolicyRuleLocalDataLocalDataOutput) Ttl() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ResponsePolicyRuleLocalDataLocalData) *int { return v.Ttl }).(pulumi.IntPtrOutput)
}

// One of valid DNS resource types.
// Possible values are: `A`, `AAAA`, `CAA`, `CNAME`, `DNSKEY`, `DS`, `HTTPS`, `IPSECVPNKEY`, `MX`, `NAPTR`, `NS`, `PTR`, `SOA`, `SPF`, `SRV`, `SSHFP`, `SVCB`, `TLSA`, `TXT`.
func (o ResponsePolicyRuleLocalDataLocalDataOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v ResponsePolicyRuleLocalDataLocalData) string { return v.Type }).(pulumi.StringOutput)
}

type ResponsePolicyRuleLocalDataLocalDataArrayOutput struct{ *pulumi.OutputState }

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

func (o ResponsePolicyRuleLocalDataLocalDataArrayOutput) ToResponsePolicyRuleLocalDataLocalDataArrayOutput() ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataLocalDataArrayOutput) ToResponsePolicyRuleLocalDataLocalDataArrayOutputWithContext(ctx context.Context) ResponsePolicyRuleLocalDataLocalDataArrayOutput {
	return o
}

func (o ResponsePolicyRuleLocalDataLocalDataArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]ResponsePolicyRuleLocalDataLocalData] {
	return pulumix.Output[[]ResponsePolicyRuleLocalDataLocalData]{
		OutputState: o.OutputState,
	}
}

func (o ResponsePolicyRuleLocalDataLocalDataArrayOutput) Index(i pulumi.IntInput) ResponsePolicyRuleLocalDataLocalDataOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResponsePolicyRuleLocalDataLocalData {
		return vs[0].([]ResponsePolicyRuleLocalDataLocalData)[vs[1].(int)]
	}).(ResponsePolicyRuleLocalDataLocalDataOutput)
}

type GetKeysKeySigningKey struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm string `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime string `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description string `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests []GetKeysKeySigningKeyDigest `pulumi:"digests"`
	// The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.
	DsRecord string `pulumi:"dsRecord"`
	// Unique identifier for the resource; defined by the server.
	Id string `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive bool `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength int `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag int `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey string `pulumi:"publicKey"`
}

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

	ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput
	ToGetKeysKeySigningKeyOutputWithContext(context.Context) GetKeysKeySigningKeyOutput
}

type GetKeysKeySigningKeyArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm pulumi.StringInput `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime pulumi.StringInput `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description pulumi.StringInput `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests GetKeysKeySigningKeyDigestArrayInput `pulumi:"digests"`
	// The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.
	DsRecord pulumi.StringInput `pulumi:"dsRecord"`
	// Unique identifier for the resource; defined by the server.
	Id pulumi.StringInput `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive pulumi.BoolInput `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength pulumi.IntInput `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag pulumi.IntInput `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey pulumi.StringInput `pulumi:"publicKey"`
}

func (GetKeysKeySigningKeyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysKeySigningKey)(nil)).Elem()
}

func (i GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput {
	return i.ToGetKeysKeySigningKeyOutputWithContext(context.Background())
}

func (i GetKeysKeySigningKeyArgs) ToGetKeysKeySigningKeyOutputWithContext(ctx context.Context) GetKeysKeySigningKeyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysKeySigningKeyOutput)
}

func (i GetKeysKeySigningKeyArgs) ToOutput(ctx context.Context) pulumix.Output[GetKeysKeySigningKey] {
	return pulumix.Output[GetKeysKeySigningKey]{
		OutputState: i.ToGetKeysKeySigningKeyOutputWithContext(ctx).OutputState,
	}
}

// GetKeysKeySigningKeyArrayInput is an input type that accepts GetKeysKeySigningKeyArray and GetKeysKeySigningKeyArrayOutput values.
// You can construct a concrete instance of `GetKeysKeySigningKeyArrayInput` via:
//
//	GetKeysKeySigningKeyArray{ GetKeysKeySigningKeyArgs{...} }
type GetKeysKeySigningKeyArrayInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput
	ToGetKeysKeySigningKeyArrayOutputWithContext(context.Context) GetKeysKeySigningKeyArrayOutput
}

type GetKeysKeySigningKeyArray []GetKeysKeySigningKeyInput

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

func (i GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput {
	return i.ToGetKeysKeySigningKeyArrayOutputWithContext(context.Background())
}

func (i GetKeysKeySigningKeyArray) ToGetKeysKeySigningKeyArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysKeySigningKeyArrayOutput)
}

func (i GetKeysKeySigningKeyArray) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysKeySigningKey] {
	return pulumix.Output[[]GetKeysKeySigningKey]{
		OutputState: i.ToGetKeysKeySigningKeyArrayOutputWithContext(ctx).OutputState,
	}
}

type GetKeysKeySigningKeyOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysKeySigningKey)(nil)).Elem()
}

func (o GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutput() GetKeysKeySigningKeyOutput {
	return o
}

func (o GetKeysKeySigningKeyOutput) ToGetKeysKeySigningKeyOutputWithContext(ctx context.Context) GetKeysKeySigningKeyOutput {
	return o
}

func (o GetKeysKeySigningKeyOutput) ToOutput(ctx context.Context) pulumix.Output[GetKeysKeySigningKey] {
	return pulumix.Output[GetKeysKeySigningKey]{
		OutputState: o.OutputState,
	}
}

// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
func (o GetKeysKeySigningKeyOutput) Algorithm() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.Algorithm }).(pulumi.StringOutput)
}

// The time that this resource was created in the control plane. This is in RFC3339 text format.
func (o GetKeysKeySigningKeyOutput) CreationTime() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.CreationTime }).(pulumi.StringOutput)
}

// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
func (o GetKeysKeySigningKeyOutput) Description() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.Description }).(pulumi.StringOutput)
}

// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
func (o GetKeysKeySigningKeyOutput) Digests() GetKeysKeySigningKeyDigestArrayOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) []GetKeysKeySigningKeyDigest { return v.Digests }).(GetKeysKeySigningKeyDigestArrayOutput)
}

// The DS record based on the KSK record. This is used when [delegating](https://cloud.google.com/dns/docs/dnssec-advanced#subdelegation) DNSSEC-signed subdomains.
func (o GetKeysKeySigningKeyOutput) DsRecord() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.DsRecord }).(pulumi.StringOutput)
}

// Unique identifier for the resource; defined by the server.
func (o GetKeysKeySigningKeyOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.Id }).(pulumi.StringOutput)
}

// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
func (o GetKeysKeySigningKeyOutput) IsActive() pulumi.BoolOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) bool { return v.IsActive }).(pulumi.BoolOutput)
}

// Length of the key in bits. Specified at creation time then immutable.
func (o GetKeysKeySigningKeyOutput) KeyLength() pulumi.IntOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) int { return v.KeyLength }).(pulumi.IntOutput)
}

// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
func (o GetKeysKeySigningKeyOutput) KeyTag() pulumi.IntOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) int { return v.KeyTag }).(pulumi.IntOutput)
}

// Base64 encoded public half of this key.
func (o GetKeysKeySigningKeyOutput) PublicKey() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKey) string { return v.PublicKey }).(pulumi.StringOutput)
}

type GetKeysKeySigningKeyArrayOutput struct{ *pulumi.OutputState }

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

func (o GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutput() GetKeysKeySigningKeyArrayOutput {
	return o
}

func (o GetKeysKeySigningKeyArrayOutput) ToGetKeysKeySigningKeyArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyArrayOutput {
	return o
}

func (o GetKeysKeySigningKeyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysKeySigningKey] {
	return pulumix.Output[[]GetKeysKeySigningKey]{
		OutputState: o.OutputState,
	}
}

func (o GetKeysKeySigningKeyArrayOutput) Index(i pulumi.IntInput) GetKeysKeySigningKeyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetKeysKeySigningKey {
		return vs[0].([]GetKeysKeySigningKey)[vs[1].(int)]
	}).(GetKeysKeySigningKeyOutput)
}

type GetKeysKeySigningKeyDigest struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest string `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type string `pulumi:"type"`
}

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

	ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput
	ToGetKeysKeySigningKeyDigestOutputWithContext(context.Context) GetKeysKeySigningKeyDigestOutput
}

type GetKeysKeySigningKeyDigestArgs struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest pulumi.StringInput `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetKeysKeySigningKeyDigestArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysKeySigningKeyDigest)(nil)).Elem()
}

func (i GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput {
	return i.ToGetKeysKeySigningKeyDigestOutputWithContext(context.Background())
}

func (i GetKeysKeySigningKeyDigestArgs) ToGetKeysKeySigningKeyDigestOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysKeySigningKeyDigestOutput)
}

func (i GetKeysKeySigningKeyDigestArgs) ToOutput(ctx context.Context) pulumix.Output[GetKeysKeySigningKeyDigest] {
	return pulumix.Output[GetKeysKeySigningKeyDigest]{
		OutputState: i.ToGetKeysKeySigningKeyDigestOutputWithContext(ctx).OutputState,
	}
}

// GetKeysKeySigningKeyDigestArrayInput is an input type that accepts GetKeysKeySigningKeyDigestArray and GetKeysKeySigningKeyDigestArrayOutput values.
// You can construct a concrete instance of `GetKeysKeySigningKeyDigestArrayInput` via:
//
//	GetKeysKeySigningKeyDigestArray{ GetKeysKeySigningKeyDigestArgs{...} }
type GetKeysKeySigningKeyDigestArrayInput interface {
	pulumi.Input

	ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput
	ToGetKeysKeySigningKeyDigestArrayOutputWithContext(context.Context) GetKeysKeySigningKeyDigestArrayOutput
}

type GetKeysKeySigningKeyDigestArray []GetKeysKeySigningKeyDigestInput

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

func (i GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput {
	return i.ToGetKeysKeySigningKeyDigestArrayOutputWithContext(context.Background())
}

func (i GetKeysKeySigningKeyDigestArray) ToGetKeysKeySigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysKeySigningKeyDigestArrayOutput)
}

func (i GetKeysKeySigningKeyDigestArray) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysKeySigningKeyDigest] {
	return pulumix.Output[[]GetKeysKeySigningKeyDigest]{
		OutputState: i.ToGetKeysKeySigningKeyDigestArrayOutputWithContext(ctx).OutputState,
	}
}

type GetKeysKeySigningKeyDigestOutput struct{ *pulumi.OutputState }

func (GetKeysKeySigningKeyDigestOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysKeySigningKeyDigest)(nil)).Elem()
}

func (o GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutput() GetKeysKeySigningKeyDigestOutput {
	return o
}

func (o GetKeysKeySigningKeyDigestOutput) ToGetKeysKeySigningKeyDigestOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestOutput {
	return o
}

func (o GetKeysKeySigningKeyDigestOutput) ToOutput(ctx context.Context) pulumix.Output[GetKeysKeySigningKeyDigest] {
	return pulumix.Output[GetKeysKeySigningKeyDigest]{
		OutputState: o.OutputState,
	}
}

// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
func (o GetKeysKeySigningKeyDigestOutput) Digest() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKeyDigest) string { return v.Digest }).(pulumi.StringOutput)
}

// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
func (o GetKeysKeySigningKeyDigestOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysKeySigningKeyDigest) string { return v.Type }).(pulumi.StringOutput)
}

type GetKeysKeySigningKeyDigestArrayOutput struct{ *pulumi.OutputState }

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

func (o GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutput() GetKeysKeySigningKeyDigestArrayOutput {
	return o
}

func (o GetKeysKeySigningKeyDigestArrayOutput) ToGetKeysKeySigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysKeySigningKeyDigestArrayOutput {
	return o
}

func (o GetKeysKeySigningKeyDigestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysKeySigningKeyDigest] {
	return pulumix.Output[[]GetKeysKeySigningKeyDigest]{
		OutputState: o.OutputState,
	}
}

func (o GetKeysKeySigningKeyDigestArrayOutput) Index(i pulumi.IntInput) GetKeysKeySigningKeyDigestOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetKeysKeySigningKeyDigest {
		return vs[0].([]GetKeysKeySigningKeyDigest)[vs[1].(int)]
	}).(GetKeysKeySigningKeyDigestOutput)
}

type GetKeysZoneSigningKey struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm string `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime string `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description string `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests []GetKeysZoneSigningKeyDigest `pulumi:"digests"`
	// Unique identifier for the resource; defined by the server.
	Id string `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive bool `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength int `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag int `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey string `pulumi:"publicKey"`
}

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

	ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput
	ToGetKeysZoneSigningKeyOutputWithContext(context.Context) GetKeysZoneSigningKeyOutput
}

type GetKeysZoneSigningKeyArgs struct {
	// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
	Algorithm pulumi.StringInput `pulumi:"algorithm"`
	// The time that this resource was created in the control plane. This is in RFC3339 text format.
	CreationTime pulumi.StringInput `pulumi:"creationTime"`
	// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
	Description pulumi.StringInput `pulumi:"description"`
	// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
	Digests GetKeysZoneSigningKeyDigestArrayInput `pulumi:"digests"`
	// Unique identifier for the resource; defined by the server.
	Id pulumi.StringInput `pulumi:"id"`
	// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
	IsActive pulumi.BoolInput `pulumi:"isActive"`
	// Length of the key in bits. Specified at creation time then immutable.
	KeyLength pulumi.IntInput `pulumi:"keyLength"`
	// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
	KeyTag pulumi.IntInput `pulumi:"keyTag"`
	// Base64 encoded public half of this key.
	PublicKey pulumi.StringInput `pulumi:"publicKey"`
}

func (GetKeysZoneSigningKeyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysZoneSigningKey)(nil)).Elem()
}

func (i GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput {
	return i.ToGetKeysZoneSigningKeyOutputWithContext(context.Background())
}

func (i GetKeysZoneSigningKeyArgs) ToGetKeysZoneSigningKeyOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysZoneSigningKeyOutput)
}

func (i GetKeysZoneSigningKeyArgs) ToOutput(ctx context.Context) pulumix.Output[GetKeysZoneSigningKey] {
	return pulumix.Output[GetKeysZoneSigningKey]{
		OutputState: i.ToGetKeysZoneSigningKeyOutputWithContext(ctx).OutputState,
	}
}

// GetKeysZoneSigningKeyArrayInput is an input type that accepts GetKeysZoneSigningKeyArray and GetKeysZoneSigningKeyArrayOutput values.
// You can construct a concrete instance of `GetKeysZoneSigningKeyArrayInput` via:
//
//	GetKeysZoneSigningKeyArray{ GetKeysZoneSigningKeyArgs{...} }
type GetKeysZoneSigningKeyArrayInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput
	ToGetKeysZoneSigningKeyArrayOutputWithContext(context.Context) GetKeysZoneSigningKeyArrayOutput
}

type GetKeysZoneSigningKeyArray []GetKeysZoneSigningKeyInput

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

func (i GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput {
	return i.ToGetKeysZoneSigningKeyArrayOutputWithContext(context.Background())
}

func (i GetKeysZoneSigningKeyArray) ToGetKeysZoneSigningKeyArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysZoneSigningKeyArrayOutput)
}

func (i GetKeysZoneSigningKeyArray) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysZoneSigningKey] {
	return pulumix.Output[[]GetKeysZoneSigningKey]{
		OutputState: i.ToGetKeysZoneSigningKeyArrayOutputWithContext(ctx).OutputState,
	}
}

type GetKeysZoneSigningKeyOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysZoneSigningKey)(nil)).Elem()
}

func (o GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutput() GetKeysZoneSigningKeyOutput {
	return o
}

func (o GetKeysZoneSigningKeyOutput) ToGetKeysZoneSigningKeyOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyOutput {
	return o
}

func (o GetKeysZoneSigningKeyOutput) ToOutput(ctx context.Context) pulumix.Output[GetKeysZoneSigningKey] {
	return pulumix.Output[GetKeysZoneSigningKey]{
		OutputState: o.OutputState,
	}
}

// String mnemonic specifying the DNSSEC algorithm of this key. Immutable after creation time. Possible values are `ecdsap256sha256`, `ecdsap384sha384`, `rsasha1`, `rsasha256`, and `rsasha512`.
func (o GetKeysZoneSigningKeyOutput) Algorithm() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) string { return v.Algorithm }).(pulumi.StringOutput)
}

// The time that this resource was created in the control plane. This is in RFC3339 text format.
func (o GetKeysZoneSigningKeyOutput) CreationTime() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) string { return v.CreationTime }).(pulumi.StringOutput)
}

// A mutable string of at most 1024 characters associated with this resource for the user's convenience.
func (o GetKeysZoneSigningKeyOutput) Description() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) string { return v.Description }).(pulumi.StringOutput)
}

// A list of cryptographic hashes of the DNSKEY resource record associated with this DnsKey. These digests are needed to construct a DS record that points at this DNS key. Each contains:
func (o GetKeysZoneSigningKeyOutput) Digests() GetKeysZoneSigningKeyDigestArrayOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) []GetKeysZoneSigningKeyDigest { return v.Digests }).(GetKeysZoneSigningKeyDigestArrayOutput)
}

// Unique identifier for the resource; defined by the server.
func (o GetKeysZoneSigningKeyOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) string { return v.Id }).(pulumi.StringOutput)
}

// Active keys will be used to sign subsequent changes to the ManagedZone. Inactive keys will still be present as DNSKEY Resource Records for the use of resolvers validating existing signatures.
func (o GetKeysZoneSigningKeyOutput) IsActive() pulumi.BoolOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) bool { return v.IsActive }).(pulumi.BoolOutput)
}

// Length of the key in bits. Specified at creation time then immutable.
func (o GetKeysZoneSigningKeyOutput) KeyLength() pulumi.IntOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) int { return v.KeyLength }).(pulumi.IntOutput)
}

// The key tag is a non-cryptographic hash of the a DNSKEY resource record associated with this DnsKey. The key tag can be used to identify a DNSKEY more quickly (but it is not a unique identifier). In particular, the key tag is used in a parent zone's DS record to point at the DNSKEY in this child ManagedZone. The key tag is a number in the range [0, 65535] and the algorithm to calculate it is specified in RFC4034 Appendix B.
func (o GetKeysZoneSigningKeyOutput) KeyTag() pulumi.IntOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) int { return v.KeyTag }).(pulumi.IntOutput)
}

// Base64 encoded public half of this key.
func (o GetKeysZoneSigningKeyOutput) PublicKey() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKey) string { return v.PublicKey }).(pulumi.StringOutput)
}

type GetKeysZoneSigningKeyArrayOutput struct{ *pulumi.OutputState }

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

func (o GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutput() GetKeysZoneSigningKeyArrayOutput {
	return o
}

func (o GetKeysZoneSigningKeyArrayOutput) ToGetKeysZoneSigningKeyArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyArrayOutput {
	return o
}

func (o GetKeysZoneSigningKeyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysZoneSigningKey] {
	return pulumix.Output[[]GetKeysZoneSigningKey]{
		OutputState: o.OutputState,
	}
}

func (o GetKeysZoneSigningKeyArrayOutput) Index(i pulumi.IntInput) GetKeysZoneSigningKeyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetKeysZoneSigningKey {
		return vs[0].([]GetKeysZoneSigningKey)[vs[1].(int)]
	}).(GetKeysZoneSigningKeyOutput)
}

type GetKeysZoneSigningKeyDigest struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest string `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type string `pulumi:"type"`
}

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

	ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput
	ToGetKeysZoneSigningKeyDigestOutputWithContext(context.Context) GetKeysZoneSigningKeyDigestOutput
}

type GetKeysZoneSigningKeyDigestArgs struct {
	// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
	Digest pulumi.StringInput `pulumi:"digest"`
	// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetKeysZoneSigningKeyDigestArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysZoneSigningKeyDigest)(nil)).Elem()
}

func (i GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput {
	return i.ToGetKeysZoneSigningKeyDigestOutputWithContext(context.Background())
}

func (i GetKeysZoneSigningKeyDigestArgs) ToGetKeysZoneSigningKeyDigestOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysZoneSigningKeyDigestOutput)
}

func (i GetKeysZoneSigningKeyDigestArgs) ToOutput(ctx context.Context) pulumix.Output[GetKeysZoneSigningKeyDigest] {
	return pulumix.Output[GetKeysZoneSigningKeyDigest]{
		OutputState: i.ToGetKeysZoneSigningKeyDigestOutputWithContext(ctx).OutputState,
	}
}

// GetKeysZoneSigningKeyDigestArrayInput is an input type that accepts GetKeysZoneSigningKeyDigestArray and GetKeysZoneSigningKeyDigestArrayOutput values.
// You can construct a concrete instance of `GetKeysZoneSigningKeyDigestArrayInput` via:
//
//	GetKeysZoneSigningKeyDigestArray{ GetKeysZoneSigningKeyDigestArgs{...} }
type GetKeysZoneSigningKeyDigestArrayInput interface {
	pulumi.Input

	ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput
	ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(context.Context) GetKeysZoneSigningKeyDigestArrayOutput
}

type GetKeysZoneSigningKeyDigestArray []GetKeysZoneSigningKeyDigestInput

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

func (i GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput {
	return i.ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(context.Background())
}

func (i GetKeysZoneSigningKeyDigestArray) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetKeysZoneSigningKeyDigestArrayOutput)
}

func (i GetKeysZoneSigningKeyDigestArray) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysZoneSigningKeyDigest] {
	return pulumix.Output[[]GetKeysZoneSigningKeyDigest]{
		OutputState: i.ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(ctx).OutputState,
	}
}

type GetKeysZoneSigningKeyDigestOutput struct{ *pulumi.OutputState }

func (GetKeysZoneSigningKeyDigestOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetKeysZoneSigningKeyDigest)(nil)).Elem()
}

func (o GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutput() GetKeysZoneSigningKeyDigestOutput {
	return o
}

func (o GetKeysZoneSigningKeyDigestOutput) ToGetKeysZoneSigningKeyDigestOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestOutput {
	return o
}

func (o GetKeysZoneSigningKeyDigestOutput) ToOutput(ctx context.Context) pulumix.Output[GetKeysZoneSigningKeyDigest] {
	return pulumix.Output[GetKeysZoneSigningKeyDigest]{
		OutputState: o.OutputState,
	}
}

// The base-16 encoded bytes of this digest. Suitable for use in a DS resource record.
func (o GetKeysZoneSigningKeyDigestOutput) Digest() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKeyDigest) string { return v.Digest }).(pulumi.StringOutput)
}

// Specifies the algorithm used to calculate this digest. Possible values are `sha1`, `sha256` and `sha384`
func (o GetKeysZoneSigningKeyDigestOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v GetKeysZoneSigningKeyDigest) string { return v.Type }).(pulumi.StringOutput)
}

type GetKeysZoneSigningKeyDigestArrayOutput struct{ *pulumi.OutputState }

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

func (o GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutput() GetKeysZoneSigningKeyDigestArrayOutput {
	return o
}

func (o GetKeysZoneSigningKeyDigestArrayOutput) ToGetKeysZoneSigningKeyDigestArrayOutputWithContext(ctx context.Context) GetKeysZoneSigningKeyDigestArrayOutput {
	return o
}

func (o GetKeysZoneSigningKeyDigestArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetKeysZoneSigningKeyDigest] {
	return pulumix.Output[[]GetKeysZoneSigningKeyDigest]{
		OutputState: o.OutputState,
	}
}

func (o GetKeysZoneSigningKeyDigestArrayOutput) Index(i pulumi.IntInput) GetKeysZoneSigningKeyDigestOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetKeysZoneSigningKeyDigest {
		return vs[0].([]GetKeysZoneSigningKeyDigest)[vs[1].(int)]
	}).(GetKeysZoneSigningKeyDigestOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*DnsManagedZoneIamBindingConditionInput)(nil)).Elem(), DnsManagedZoneIamBindingConditionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DnsManagedZoneIamBindingConditionPtrInput)(nil)).Elem(), DnsManagedZoneIamBindingConditionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DnsManagedZoneIamMemberConditionInput)(nil)).Elem(), DnsManagedZoneIamMemberConditionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DnsManagedZoneIamMemberConditionPtrInput)(nil)).Elem(), DnsManagedZoneIamMemberConditionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneCloudLoggingConfigInput)(nil)).Elem(), ManagedZoneCloudLoggingConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneCloudLoggingConfigPtrInput)(nil)).Elem(), ManagedZoneCloudLoggingConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneDnssecConfigInput)(nil)).Elem(), ManagedZoneDnssecConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneDnssecConfigPtrInput)(nil)).Elem(), ManagedZoneDnssecConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneDnssecConfigDefaultKeySpecInput)(nil)).Elem(), ManagedZoneDnssecConfigDefaultKeySpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneDnssecConfigDefaultKeySpecArrayInput)(nil)).Elem(), ManagedZoneDnssecConfigDefaultKeySpecArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneForwardingConfigInput)(nil)).Elem(), ManagedZoneForwardingConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneForwardingConfigPtrInput)(nil)).Elem(), ManagedZoneForwardingConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneForwardingConfigTargetNameServerInput)(nil)).Elem(), ManagedZoneForwardingConfigTargetNameServerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneForwardingConfigTargetNameServerArrayInput)(nil)).Elem(), ManagedZoneForwardingConfigTargetNameServerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePeeringConfigInput)(nil)).Elem(), ManagedZonePeeringConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePeeringConfigPtrInput)(nil)).Elem(), ManagedZonePeeringConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePeeringConfigTargetNetworkInput)(nil)).Elem(), ManagedZonePeeringConfigTargetNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePeeringConfigTargetNetworkPtrInput)(nil)).Elem(), ManagedZonePeeringConfigTargetNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigPtrInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigGkeClusterInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigGkeClusterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigGkeClusterArrayInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigGkeClusterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigNetworkInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZonePrivateVisibilityConfigNetworkArrayInput)(nil)).Elem(), ManagedZonePrivateVisibilityConfigNetworkArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneServiceDirectoryConfigInput)(nil)).Elem(), ManagedZoneServiceDirectoryConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneServiceDirectoryConfigPtrInput)(nil)).Elem(), ManagedZoneServiceDirectoryConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneServiceDirectoryConfigNamespaceInput)(nil)).Elem(), ManagedZoneServiceDirectoryConfigNamespaceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedZoneServiceDirectoryConfigNamespacePtrInput)(nil)).Elem(), ManagedZoneServiceDirectoryConfigNamespaceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyAlternativeNameServerConfigInput)(nil)).Elem(), PolicyAlternativeNameServerConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyAlternativeNameServerConfigPtrInput)(nil)).Elem(), PolicyAlternativeNameServerConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyAlternativeNameServerConfigTargetNameServerInput)(nil)).Elem(), PolicyAlternativeNameServerConfigTargetNameServerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyAlternativeNameServerConfigTargetNameServerArrayInput)(nil)).Elem(), PolicyAlternativeNameServerConfigTargetNameServerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyNetworkInput)(nil)).Elem(), PolicyNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PolicyNetworkArrayInput)(nil)).Elem(), PolicyNetworkArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyInput)(nil)).Elem(), RecordSetRoutingPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPtrInput)(nil)).Elem(), RecordSetRoutingPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoInput)(nil)).Elem(), RecordSetRoutingPolicyGeoArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoArrayInput)(nil)).Elem(), RecordSetRoutingPolicyGeoArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsInput)(nil)).Elem(), RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrInput)(nil)).Elem(), RecordSetRoutingPolicyGeoHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerInput)(nil)).Elem(), RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayInput)(nil)).Elem(), RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPtrInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupPrimaryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryPtrInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupPrimaryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayInput)(nil)).Elem(), RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrInput)(nil)).Elem(), RecordSetRoutingPolicyWrrArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrArrayInput)(nil)).Elem(), RecordSetRoutingPolicyWrrArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsInput)(nil)).Elem(), RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrInput)(nil)).Elem(), RecordSetRoutingPolicyWrrHealthCheckedTargetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerInput)(nil)).Elem(), RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayInput)(nil)).Elem(), RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyGkeClusterInput)(nil)).Elem(), ResponsePolicyGkeClusterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyGkeClusterArrayInput)(nil)).Elem(), ResponsePolicyGkeClusterArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyNetworkInput)(nil)).Elem(), ResponsePolicyNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyNetworkArrayInput)(nil)).Elem(), ResponsePolicyNetworkArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyRuleLocalDataInput)(nil)).Elem(), ResponsePolicyRuleLocalDataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyRuleLocalDataPtrInput)(nil)).Elem(), ResponsePolicyRuleLocalDataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyRuleLocalDataLocalDataInput)(nil)).Elem(), ResponsePolicyRuleLocalDataLocalDataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResponsePolicyRuleLocalDataLocalDataArrayInput)(nil)).Elem(), ResponsePolicyRuleLocalDataLocalDataArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysKeySigningKeyInput)(nil)).Elem(), GetKeysKeySigningKeyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysKeySigningKeyArrayInput)(nil)).Elem(), GetKeysKeySigningKeyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysKeySigningKeyDigestInput)(nil)).Elem(), GetKeysKeySigningKeyDigestArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysKeySigningKeyDigestArrayInput)(nil)).Elem(), GetKeysKeySigningKeyDigestArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysZoneSigningKeyInput)(nil)).Elem(), GetKeysZoneSigningKeyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysZoneSigningKeyArrayInput)(nil)).Elem(), GetKeysZoneSigningKeyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysZoneSigningKeyDigestInput)(nil)).Elem(), GetKeysZoneSigningKeyDigestArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetKeysZoneSigningKeyDigestArrayInput)(nil)).Elem(), GetKeysZoneSigningKeyDigestArray{})
	pulumi.RegisterOutputType(DnsManagedZoneIamBindingConditionOutput{})
	pulumi.RegisterOutputType(DnsManagedZoneIamBindingConditionPtrOutput{})
	pulumi.RegisterOutputType(DnsManagedZoneIamMemberConditionOutput{})
	pulumi.RegisterOutputType(DnsManagedZoneIamMemberConditionPtrOutput{})
	pulumi.RegisterOutputType(ManagedZoneCloudLoggingConfigOutput{})
	pulumi.RegisterOutputType(ManagedZoneCloudLoggingConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZoneDnssecConfigOutput{})
	pulumi.RegisterOutputType(ManagedZoneDnssecConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZoneDnssecConfigDefaultKeySpecOutput{})
	pulumi.RegisterOutputType(ManagedZoneDnssecConfigDefaultKeySpecArrayOutput{})
	pulumi.RegisterOutputType(ManagedZoneForwardingConfigOutput{})
	pulumi.RegisterOutputType(ManagedZoneForwardingConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZoneForwardingConfigTargetNameServerOutput{})
	pulumi.RegisterOutputType(ManagedZoneForwardingConfigTargetNameServerArrayOutput{})
	pulumi.RegisterOutputType(ManagedZonePeeringConfigOutput{})
	pulumi.RegisterOutputType(ManagedZonePeeringConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZonePeeringConfigTargetNetworkOutput{})
	pulumi.RegisterOutputType(ManagedZonePeeringConfigTargetNetworkPtrOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigGkeClusterOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigGkeClusterArrayOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigNetworkOutput{})
	pulumi.RegisterOutputType(ManagedZonePrivateVisibilityConfigNetworkArrayOutput{})
	pulumi.RegisterOutputType(ManagedZoneServiceDirectoryConfigOutput{})
	pulumi.RegisterOutputType(ManagedZoneServiceDirectoryConfigPtrOutput{})
	pulumi.RegisterOutputType(ManagedZoneServiceDirectoryConfigNamespaceOutput{})
	pulumi.RegisterOutputType(ManagedZoneServiceDirectoryConfigNamespacePtrOutput{})
	pulumi.RegisterOutputType(PolicyAlternativeNameServerConfigOutput{})
	pulumi.RegisterOutputType(PolicyAlternativeNameServerConfigPtrOutput{})
	pulumi.RegisterOutputType(PolicyAlternativeNameServerConfigTargetNameServerOutput{})
	pulumi.RegisterOutputType(PolicyAlternativeNameServerConfigTargetNameServerArrayOutput{})
	pulumi.RegisterOutputType(PolicyNetworkOutput{})
	pulumi.RegisterOutputType(PolicyNetworkArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoHealthCheckedTargetsOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoHealthCheckedTargetsPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupBackupGeoHealthCheckedTargetsInternalLoadBalancerArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupPrimaryOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupPrimaryPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyPrimaryBackupPrimaryInternalLoadBalancerArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrArrayOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrHealthCheckedTargetsOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrHealthCheckedTargetsPtrOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerOutput{})
	pulumi.RegisterOutputType(RecordSetRoutingPolicyWrrHealthCheckedTargetsInternalLoadBalancerArrayOutput{})
	pulumi.RegisterOutputType(ResponsePolicyGkeClusterOutput{})
	pulumi.RegisterOutputType(ResponsePolicyGkeClusterArrayOutput{})
	pulumi.RegisterOutputType(ResponsePolicyNetworkOutput{})
	pulumi.RegisterOutputType(ResponsePolicyNetworkArrayOutput{})
	pulumi.RegisterOutputType(ResponsePolicyRuleLocalDataOutput{})
	pulumi.RegisterOutputType(ResponsePolicyRuleLocalDataPtrOutput{})
	pulumi.RegisterOutputType(ResponsePolicyRuleLocalDataLocalDataOutput{})
	pulumi.RegisterOutputType(ResponsePolicyRuleLocalDataLocalDataArrayOutput{})
	pulumi.RegisterOutputType(GetKeysKeySigningKeyOutput{})
	pulumi.RegisterOutputType(GetKeysKeySigningKeyArrayOutput{})
	pulumi.RegisterOutputType(GetKeysKeySigningKeyDigestOutput{})
	pulumi.RegisterOutputType(GetKeysKeySigningKeyDigestArrayOutput{})
	pulumi.RegisterOutputType(GetKeysZoneSigningKeyOutput{})
	pulumi.RegisterOutputType(GetKeysZoneSigningKeyArrayOutput{})
	pulumi.RegisterOutputType(GetKeysZoneSigningKeyDigestOutput{})
	pulumi.RegisterOutputType(GetKeysZoneSigningKeyDigestArrayOutput{})
}