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 ipsec

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-fortios/sdk/go/fortios/internal"
)

var _ = internal.GetEnvOrDefault

type ConcentratorMember struct {
	// Member name.
	Name *string `pulumi:"name"`
}

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

	ToConcentratorMemberOutput() ConcentratorMemberOutput
	ToConcentratorMemberOutputWithContext(context.Context) ConcentratorMemberOutput
}

type ConcentratorMemberArgs struct {
	// Member name.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (ConcentratorMemberArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ConcentratorMember)(nil)).Elem()
}

func (i ConcentratorMemberArgs) ToConcentratorMemberOutput() ConcentratorMemberOutput {
	return i.ToConcentratorMemberOutputWithContext(context.Background())
}

func (i ConcentratorMemberArgs) ToConcentratorMemberOutputWithContext(ctx context.Context) ConcentratorMemberOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConcentratorMemberOutput)
}

// ConcentratorMemberArrayInput is an input type that accepts ConcentratorMemberArray and ConcentratorMemberArrayOutput values.
// You can construct a concrete instance of `ConcentratorMemberArrayInput` via:
//
//	ConcentratorMemberArray{ ConcentratorMemberArgs{...} }
type ConcentratorMemberArrayInput interface {
	pulumi.Input

	ToConcentratorMemberArrayOutput() ConcentratorMemberArrayOutput
	ToConcentratorMemberArrayOutputWithContext(context.Context) ConcentratorMemberArrayOutput
}

type ConcentratorMemberArray []ConcentratorMemberInput

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

func (i ConcentratorMemberArray) ToConcentratorMemberArrayOutput() ConcentratorMemberArrayOutput {
	return i.ToConcentratorMemberArrayOutputWithContext(context.Background())
}

func (i ConcentratorMemberArray) ToConcentratorMemberArrayOutputWithContext(ctx context.Context) ConcentratorMemberArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConcentratorMemberArrayOutput)
}

type ConcentratorMemberOutput struct{ *pulumi.OutputState }

func (ConcentratorMemberOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ConcentratorMember)(nil)).Elem()
}

func (o ConcentratorMemberOutput) ToConcentratorMemberOutput() ConcentratorMemberOutput {
	return o
}

func (o ConcentratorMemberOutput) ToConcentratorMemberOutputWithContext(ctx context.Context) ConcentratorMemberOutput {
	return o
}

// Member name.
func (o ConcentratorMemberOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ConcentratorMember) *string { return v.Name }).(pulumi.StringPtrOutput)
}

type ConcentratorMemberArrayOutput struct{ *pulumi.OutputState }

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

func (o ConcentratorMemberArrayOutput) ToConcentratorMemberArrayOutput() ConcentratorMemberArrayOutput {
	return o
}

func (o ConcentratorMemberArrayOutput) ToConcentratorMemberArrayOutputWithContext(ctx context.Context) ConcentratorMemberArrayOutput {
	return o
}

func (o ConcentratorMemberArrayOutput) Index(i pulumi.IntInput) ConcentratorMemberOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConcentratorMember {
		return vs[0].([]ConcentratorMember)[vs[1].(int)]
	}).(ConcentratorMemberOutput)
}

type FecMapping struct {
	// Apply FEC parameters when available bi-bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthBiThreshold *int `pulumi:"bandwidthBiThreshold"`
	// Apply FEC parameters when available down bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthDownThreshold *int `pulumi:"bandwidthDownThreshold"`
	// Apply FEC parameters when available up bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthUpThreshold *int `pulumi:"bandwidthUpThreshold"`
	// Number of base FEC packets (1 - 20).
	Base *int `pulumi:"base"`
	// Apply FEC parameters when latency is <= threshold (0 means no threshold).
	LatencyThreshold *int `pulumi:"latencyThreshold"`
	// Apply FEC parameters when packet loss is >= threshold (0 - 100, 0 means no threshold).
	PacketLossThreshold *int `pulumi:"packetLossThreshold"`
	// Number of redundant FEC packets (1 - 5).
	Redundant *int `pulumi:"redundant"`
	// Sequence number (1 - 64).
	Seqno *int `pulumi:"seqno"`
}

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

	ToFecMappingOutput() FecMappingOutput
	ToFecMappingOutputWithContext(context.Context) FecMappingOutput
}

type FecMappingArgs struct {
	// Apply FEC parameters when available bi-bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthBiThreshold pulumi.IntPtrInput `pulumi:"bandwidthBiThreshold"`
	// Apply FEC parameters when available down bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthDownThreshold pulumi.IntPtrInput `pulumi:"bandwidthDownThreshold"`
	// Apply FEC parameters when available up bandwidth is >= threshold (kbps, 0 means no threshold).
	BandwidthUpThreshold pulumi.IntPtrInput `pulumi:"bandwidthUpThreshold"`
	// Number of base FEC packets (1 - 20).
	Base pulumi.IntPtrInput `pulumi:"base"`
	// Apply FEC parameters when latency is <= threshold (0 means no threshold).
	LatencyThreshold pulumi.IntPtrInput `pulumi:"latencyThreshold"`
	// Apply FEC parameters when packet loss is >= threshold (0 - 100, 0 means no threshold).
	PacketLossThreshold pulumi.IntPtrInput `pulumi:"packetLossThreshold"`
	// Number of redundant FEC packets (1 - 5).
	Redundant pulumi.IntPtrInput `pulumi:"redundant"`
	// Sequence number (1 - 64).
	Seqno pulumi.IntPtrInput `pulumi:"seqno"`
}

func (FecMappingArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FecMapping)(nil)).Elem()
}

func (i FecMappingArgs) ToFecMappingOutput() FecMappingOutput {
	return i.ToFecMappingOutputWithContext(context.Background())
}

func (i FecMappingArgs) ToFecMappingOutputWithContext(ctx context.Context) FecMappingOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FecMappingOutput)
}

// FecMappingArrayInput is an input type that accepts FecMappingArray and FecMappingArrayOutput values.
// You can construct a concrete instance of `FecMappingArrayInput` via:
//
//	FecMappingArray{ FecMappingArgs{...} }
type FecMappingArrayInput interface {
	pulumi.Input

	ToFecMappingArrayOutput() FecMappingArrayOutput
	ToFecMappingArrayOutputWithContext(context.Context) FecMappingArrayOutput
}

type FecMappingArray []FecMappingInput

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

func (i FecMappingArray) ToFecMappingArrayOutput() FecMappingArrayOutput {
	return i.ToFecMappingArrayOutputWithContext(context.Background())
}

func (i FecMappingArray) ToFecMappingArrayOutputWithContext(ctx context.Context) FecMappingArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FecMappingArrayOutput)
}

type FecMappingOutput struct{ *pulumi.OutputState }

func (FecMappingOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FecMapping)(nil)).Elem()
}

func (o FecMappingOutput) ToFecMappingOutput() FecMappingOutput {
	return o
}

func (o FecMappingOutput) ToFecMappingOutputWithContext(ctx context.Context) FecMappingOutput {
	return o
}

// Apply FEC parameters when available bi-bandwidth is >= threshold (kbps, 0 means no threshold).
func (o FecMappingOutput) BandwidthBiThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.BandwidthBiThreshold }).(pulumi.IntPtrOutput)
}

// Apply FEC parameters when available down bandwidth is >= threshold (kbps, 0 means no threshold).
func (o FecMappingOutput) BandwidthDownThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.BandwidthDownThreshold }).(pulumi.IntPtrOutput)
}

// Apply FEC parameters when available up bandwidth is >= threshold (kbps, 0 means no threshold).
func (o FecMappingOutput) BandwidthUpThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.BandwidthUpThreshold }).(pulumi.IntPtrOutput)
}

// Number of base FEC packets (1 - 20).
func (o FecMappingOutput) Base() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.Base }).(pulumi.IntPtrOutput)
}

// Apply FEC parameters when latency is <= threshold (0 means no threshold).
func (o FecMappingOutput) LatencyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.LatencyThreshold }).(pulumi.IntPtrOutput)
}

// Apply FEC parameters when packet loss is >= threshold (0 - 100, 0 means no threshold).
func (o FecMappingOutput) PacketLossThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.PacketLossThreshold }).(pulumi.IntPtrOutput)
}

// Number of redundant FEC packets (1 - 5).
func (o FecMappingOutput) Redundant() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.Redundant }).(pulumi.IntPtrOutput)
}

// Sequence number (1 - 64).
func (o FecMappingOutput) Seqno() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FecMapping) *int { return v.Seqno }).(pulumi.IntPtrOutput)
}

type FecMappingArrayOutput struct{ *pulumi.OutputState }

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

func (o FecMappingArrayOutput) ToFecMappingArrayOutput() FecMappingArrayOutput {
	return o
}

func (o FecMappingArrayOutput) ToFecMappingArrayOutputWithContext(ctx context.Context) FecMappingArrayOutput {
	return o
}

func (o FecMappingArrayOutput) Index(i pulumi.IntInput) FecMappingOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) FecMapping {
		return vs[0].([]FecMapping)[vs[1].(int)]
	}).(FecMappingOutput)
}

type Phase1BackupGateway struct {
	// Address of backup gateway.
	Address *string `pulumi:"address"`
}

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

	ToPhase1BackupGatewayOutput() Phase1BackupGatewayOutput
	ToPhase1BackupGatewayOutputWithContext(context.Context) Phase1BackupGatewayOutput
}

type Phase1BackupGatewayArgs struct {
	// Address of backup gateway.
	Address pulumi.StringPtrInput `pulumi:"address"`
}

func (Phase1BackupGatewayArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1BackupGateway)(nil)).Elem()
}

func (i Phase1BackupGatewayArgs) ToPhase1BackupGatewayOutput() Phase1BackupGatewayOutput {
	return i.ToPhase1BackupGatewayOutputWithContext(context.Background())
}

func (i Phase1BackupGatewayArgs) ToPhase1BackupGatewayOutputWithContext(ctx context.Context) Phase1BackupGatewayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1BackupGatewayOutput)
}

// Phase1BackupGatewayArrayInput is an input type that accepts Phase1BackupGatewayArray and Phase1BackupGatewayArrayOutput values.
// You can construct a concrete instance of `Phase1BackupGatewayArrayInput` via:
//
//	Phase1BackupGatewayArray{ Phase1BackupGatewayArgs{...} }
type Phase1BackupGatewayArrayInput interface {
	pulumi.Input

	ToPhase1BackupGatewayArrayOutput() Phase1BackupGatewayArrayOutput
	ToPhase1BackupGatewayArrayOutputWithContext(context.Context) Phase1BackupGatewayArrayOutput
}

type Phase1BackupGatewayArray []Phase1BackupGatewayInput

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

func (i Phase1BackupGatewayArray) ToPhase1BackupGatewayArrayOutput() Phase1BackupGatewayArrayOutput {
	return i.ToPhase1BackupGatewayArrayOutputWithContext(context.Background())
}

func (i Phase1BackupGatewayArray) ToPhase1BackupGatewayArrayOutputWithContext(ctx context.Context) Phase1BackupGatewayArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1BackupGatewayArrayOutput)
}

type Phase1BackupGatewayOutput struct{ *pulumi.OutputState }

func (Phase1BackupGatewayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1BackupGateway)(nil)).Elem()
}

func (o Phase1BackupGatewayOutput) ToPhase1BackupGatewayOutput() Phase1BackupGatewayOutput {
	return o
}

func (o Phase1BackupGatewayOutput) ToPhase1BackupGatewayOutputWithContext(ctx context.Context) Phase1BackupGatewayOutput {
	return o
}

// Address of backup gateway.
func (o Phase1BackupGatewayOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1BackupGateway) *string { return v.Address }).(pulumi.StringPtrOutput)
}

type Phase1BackupGatewayArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1BackupGatewayArrayOutput) ToPhase1BackupGatewayArrayOutput() Phase1BackupGatewayArrayOutput {
	return o
}

func (o Phase1BackupGatewayArrayOutput) ToPhase1BackupGatewayArrayOutputWithContext(ctx context.Context) Phase1BackupGatewayArrayOutput {
	return o
}

func (o Phase1BackupGatewayArrayOutput) Index(i pulumi.IntInput) Phase1BackupGatewayOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1BackupGateway {
		return vs[0].([]Phase1BackupGateway)[vs[1].(int)]
	}).(Phase1BackupGatewayOutput)
}

type Phase1Certificate struct {
	// Certificate name.
	Name *string `pulumi:"name"`
}

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

	ToPhase1CertificateOutput() Phase1CertificateOutput
	ToPhase1CertificateOutputWithContext(context.Context) Phase1CertificateOutput
}

type Phase1CertificateArgs struct {
	// Certificate name.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (Phase1CertificateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Certificate)(nil)).Elem()
}

func (i Phase1CertificateArgs) ToPhase1CertificateOutput() Phase1CertificateOutput {
	return i.ToPhase1CertificateOutputWithContext(context.Background())
}

func (i Phase1CertificateArgs) ToPhase1CertificateOutputWithContext(ctx context.Context) Phase1CertificateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1CertificateOutput)
}

// Phase1CertificateArrayInput is an input type that accepts Phase1CertificateArray and Phase1CertificateArrayOutput values.
// You can construct a concrete instance of `Phase1CertificateArrayInput` via:
//
//	Phase1CertificateArray{ Phase1CertificateArgs{...} }
type Phase1CertificateArrayInput interface {
	pulumi.Input

	ToPhase1CertificateArrayOutput() Phase1CertificateArrayOutput
	ToPhase1CertificateArrayOutputWithContext(context.Context) Phase1CertificateArrayOutput
}

type Phase1CertificateArray []Phase1CertificateInput

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

func (i Phase1CertificateArray) ToPhase1CertificateArrayOutput() Phase1CertificateArrayOutput {
	return i.ToPhase1CertificateArrayOutputWithContext(context.Background())
}

func (i Phase1CertificateArray) ToPhase1CertificateArrayOutputWithContext(ctx context.Context) Phase1CertificateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1CertificateArrayOutput)
}

type Phase1CertificateOutput struct{ *pulumi.OutputState }

func (Phase1CertificateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Certificate)(nil)).Elem()
}

func (o Phase1CertificateOutput) ToPhase1CertificateOutput() Phase1CertificateOutput {
	return o
}

func (o Phase1CertificateOutput) ToPhase1CertificateOutputWithContext(ctx context.Context) Phase1CertificateOutput {
	return o
}

// Certificate name.
func (o Phase1CertificateOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1Certificate) *string { return v.Name }).(pulumi.StringPtrOutput)
}

type Phase1CertificateArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1CertificateArrayOutput) ToPhase1CertificateArrayOutput() Phase1CertificateArrayOutput {
	return o
}

func (o Phase1CertificateArrayOutput) ToPhase1CertificateArrayOutputWithContext(ctx context.Context) Phase1CertificateArrayOutput {
	return o
}

func (o Phase1CertificateArrayOutput) Index(i pulumi.IntInput) Phase1CertificateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1Certificate {
		return vs[0].([]Phase1Certificate)[vs[1].(int)]
	}).(Phase1CertificateOutput)
}

type Phase1InternalDomainList struct {
	// Domain name.
	//
	// The `ipv4ExcludeRange` block supports:
	DomainName *string `pulumi:"domainName"`
}

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

	ToPhase1InternalDomainListOutput() Phase1InternalDomainListOutput
	ToPhase1InternalDomainListOutputWithContext(context.Context) Phase1InternalDomainListOutput
}

type Phase1InternalDomainListArgs struct {
	// Domain name.
	//
	// The `ipv4ExcludeRange` block supports:
	DomainName pulumi.StringPtrInput `pulumi:"domainName"`
}

func (Phase1InternalDomainListArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1InternalDomainList)(nil)).Elem()
}

func (i Phase1InternalDomainListArgs) ToPhase1InternalDomainListOutput() Phase1InternalDomainListOutput {
	return i.ToPhase1InternalDomainListOutputWithContext(context.Background())
}

func (i Phase1InternalDomainListArgs) ToPhase1InternalDomainListOutputWithContext(ctx context.Context) Phase1InternalDomainListOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1InternalDomainListOutput)
}

// Phase1InternalDomainListArrayInput is an input type that accepts Phase1InternalDomainListArray and Phase1InternalDomainListArrayOutput values.
// You can construct a concrete instance of `Phase1InternalDomainListArrayInput` via:
//
//	Phase1InternalDomainListArray{ Phase1InternalDomainListArgs{...} }
type Phase1InternalDomainListArrayInput interface {
	pulumi.Input

	ToPhase1InternalDomainListArrayOutput() Phase1InternalDomainListArrayOutput
	ToPhase1InternalDomainListArrayOutputWithContext(context.Context) Phase1InternalDomainListArrayOutput
}

type Phase1InternalDomainListArray []Phase1InternalDomainListInput

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

func (i Phase1InternalDomainListArray) ToPhase1InternalDomainListArrayOutput() Phase1InternalDomainListArrayOutput {
	return i.ToPhase1InternalDomainListArrayOutputWithContext(context.Background())
}

func (i Phase1InternalDomainListArray) ToPhase1InternalDomainListArrayOutputWithContext(ctx context.Context) Phase1InternalDomainListArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1InternalDomainListArrayOutput)
}

type Phase1InternalDomainListOutput struct{ *pulumi.OutputState }

func (Phase1InternalDomainListOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1InternalDomainList)(nil)).Elem()
}

func (o Phase1InternalDomainListOutput) ToPhase1InternalDomainListOutput() Phase1InternalDomainListOutput {
	return o
}

func (o Phase1InternalDomainListOutput) ToPhase1InternalDomainListOutputWithContext(ctx context.Context) Phase1InternalDomainListOutput {
	return o
}

// Domain name.
//
// The `ipv4ExcludeRange` block supports:
func (o Phase1InternalDomainListOutput) DomainName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1InternalDomainList) *string { return v.DomainName }).(pulumi.StringPtrOutput)
}

type Phase1InternalDomainListArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1InternalDomainListArrayOutput) ToPhase1InternalDomainListArrayOutput() Phase1InternalDomainListArrayOutput {
	return o
}

func (o Phase1InternalDomainListArrayOutput) ToPhase1InternalDomainListArrayOutputWithContext(ctx context.Context) Phase1InternalDomainListArrayOutput {
	return o
}

func (o Phase1InternalDomainListArrayOutput) Index(i pulumi.IntInput) Phase1InternalDomainListOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1InternalDomainList {
		return vs[0].([]Phase1InternalDomainList)[vs[1].(int)]
	}).(Phase1InternalDomainListOutput)
}

type Phase1Ipv4ExcludeRange struct {
	// End of IPv6 exclusive range.
	EndIp *string `pulumi:"endIp"`
	// ID.
	Id *int `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp *string `pulumi:"startIp"`
}

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

	ToPhase1Ipv4ExcludeRangeOutput() Phase1Ipv4ExcludeRangeOutput
	ToPhase1Ipv4ExcludeRangeOutputWithContext(context.Context) Phase1Ipv4ExcludeRangeOutput
}

type Phase1Ipv4ExcludeRangeArgs struct {
	// End of IPv6 exclusive range.
	EndIp pulumi.StringPtrInput `pulumi:"endIp"`
	// ID.
	Id pulumi.IntPtrInput `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp pulumi.StringPtrInput `pulumi:"startIp"`
}

func (Phase1Ipv4ExcludeRangeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Ipv4ExcludeRange)(nil)).Elem()
}

func (i Phase1Ipv4ExcludeRangeArgs) ToPhase1Ipv4ExcludeRangeOutput() Phase1Ipv4ExcludeRangeOutput {
	return i.ToPhase1Ipv4ExcludeRangeOutputWithContext(context.Background())
}

func (i Phase1Ipv4ExcludeRangeArgs) ToPhase1Ipv4ExcludeRangeOutputWithContext(ctx context.Context) Phase1Ipv4ExcludeRangeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1Ipv4ExcludeRangeOutput)
}

// Phase1Ipv4ExcludeRangeArrayInput is an input type that accepts Phase1Ipv4ExcludeRangeArray and Phase1Ipv4ExcludeRangeArrayOutput values.
// You can construct a concrete instance of `Phase1Ipv4ExcludeRangeArrayInput` via:
//
//	Phase1Ipv4ExcludeRangeArray{ Phase1Ipv4ExcludeRangeArgs{...} }
type Phase1Ipv4ExcludeRangeArrayInput interface {
	pulumi.Input

	ToPhase1Ipv4ExcludeRangeArrayOutput() Phase1Ipv4ExcludeRangeArrayOutput
	ToPhase1Ipv4ExcludeRangeArrayOutputWithContext(context.Context) Phase1Ipv4ExcludeRangeArrayOutput
}

type Phase1Ipv4ExcludeRangeArray []Phase1Ipv4ExcludeRangeInput

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

func (i Phase1Ipv4ExcludeRangeArray) ToPhase1Ipv4ExcludeRangeArrayOutput() Phase1Ipv4ExcludeRangeArrayOutput {
	return i.ToPhase1Ipv4ExcludeRangeArrayOutputWithContext(context.Background())
}

func (i Phase1Ipv4ExcludeRangeArray) ToPhase1Ipv4ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1Ipv4ExcludeRangeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1Ipv4ExcludeRangeArrayOutput)
}

type Phase1Ipv4ExcludeRangeOutput struct{ *pulumi.OutputState }

func (Phase1Ipv4ExcludeRangeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Ipv4ExcludeRange)(nil)).Elem()
}

func (o Phase1Ipv4ExcludeRangeOutput) ToPhase1Ipv4ExcludeRangeOutput() Phase1Ipv4ExcludeRangeOutput {
	return o
}

func (o Phase1Ipv4ExcludeRangeOutput) ToPhase1Ipv4ExcludeRangeOutputWithContext(ctx context.Context) Phase1Ipv4ExcludeRangeOutput {
	return o
}

// End of IPv6 exclusive range.
func (o Phase1Ipv4ExcludeRangeOutput) EndIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1Ipv4ExcludeRange) *string { return v.EndIp }).(pulumi.StringPtrOutput)
}

// ID.
func (o Phase1Ipv4ExcludeRangeOutput) Id() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Phase1Ipv4ExcludeRange) *int { return v.Id }).(pulumi.IntPtrOutput)
}

// Start of IPv6 exclusive range.
func (o Phase1Ipv4ExcludeRangeOutput) StartIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1Ipv4ExcludeRange) *string { return v.StartIp }).(pulumi.StringPtrOutput)
}

type Phase1Ipv4ExcludeRangeArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1Ipv4ExcludeRangeArrayOutput) ToPhase1Ipv4ExcludeRangeArrayOutput() Phase1Ipv4ExcludeRangeArrayOutput {
	return o
}

func (o Phase1Ipv4ExcludeRangeArrayOutput) ToPhase1Ipv4ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1Ipv4ExcludeRangeArrayOutput {
	return o
}

func (o Phase1Ipv4ExcludeRangeArrayOutput) Index(i pulumi.IntInput) Phase1Ipv4ExcludeRangeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1Ipv4ExcludeRange {
		return vs[0].([]Phase1Ipv4ExcludeRange)[vs[1].(int)]
	}).(Phase1Ipv4ExcludeRangeOutput)
}

type Phase1Ipv6ExcludeRange struct {
	// End of IPv6 exclusive range.
	EndIp *string `pulumi:"endIp"`
	// ID.
	Id *int `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp *string `pulumi:"startIp"`
}

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

	ToPhase1Ipv6ExcludeRangeOutput() Phase1Ipv6ExcludeRangeOutput
	ToPhase1Ipv6ExcludeRangeOutputWithContext(context.Context) Phase1Ipv6ExcludeRangeOutput
}

type Phase1Ipv6ExcludeRangeArgs struct {
	// End of IPv6 exclusive range.
	EndIp pulumi.StringPtrInput `pulumi:"endIp"`
	// ID.
	Id pulumi.IntPtrInput `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp pulumi.StringPtrInput `pulumi:"startIp"`
}

func (Phase1Ipv6ExcludeRangeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Ipv6ExcludeRange)(nil)).Elem()
}

func (i Phase1Ipv6ExcludeRangeArgs) ToPhase1Ipv6ExcludeRangeOutput() Phase1Ipv6ExcludeRangeOutput {
	return i.ToPhase1Ipv6ExcludeRangeOutputWithContext(context.Background())
}

func (i Phase1Ipv6ExcludeRangeArgs) ToPhase1Ipv6ExcludeRangeOutputWithContext(ctx context.Context) Phase1Ipv6ExcludeRangeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1Ipv6ExcludeRangeOutput)
}

// Phase1Ipv6ExcludeRangeArrayInput is an input type that accepts Phase1Ipv6ExcludeRangeArray and Phase1Ipv6ExcludeRangeArrayOutput values.
// You can construct a concrete instance of `Phase1Ipv6ExcludeRangeArrayInput` via:
//
//	Phase1Ipv6ExcludeRangeArray{ Phase1Ipv6ExcludeRangeArgs{...} }
type Phase1Ipv6ExcludeRangeArrayInput interface {
	pulumi.Input

	ToPhase1Ipv6ExcludeRangeArrayOutput() Phase1Ipv6ExcludeRangeArrayOutput
	ToPhase1Ipv6ExcludeRangeArrayOutputWithContext(context.Context) Phase1Ipv6ExcludeRangeArrayOutput
}

type Phase1Ipv6ExcludeRangeArray []Phase1Ipv6ExcludeRangeInput

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

func (i Phase1Ipv6ExcludeRangeArray) ToPhase1Ipv6ExcludeRangeArrayOutput() Phase1Ipv6ExcludeRangeArrayOutput {
	return i.ToPhase1Ipv6ExcludeRangeArrayOutputWithContext(context.Background())
}

func (i Phase1Ipv6ExcludeRangeArray) ToPhase1Ipv6ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1Ipv6ExcludeRangeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1Ipv6ExcludeRangeArrayOutput)
}

type Phase1Ipv6ExcludeRangeOutput struct{ *pulumi.OutputState }

func (Phase1Ipv6ExcludeRangeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1Ipv6ExcludeRange)(nil)).Elem()
}

func (o Phase1Ipv6ExcludeRangeOutput) ToPhase1Ipv6ExcludeRangeOutput() Phase1Ipv6ExcludeRangeOutput {
	return o
}

func (o Phase1Ipv6ExcludeRangeOutput) ToPhase1Ipv6ExcludeRangeOutputWithContext(ctx context.Context) Phase1Ipv6ExcludeRangeOutput {
	return o
}

// End of IPv6 exclusive range.
func (o Phase1Ipv6ExcludeRangeOutput) EndIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1Ipv6ExcludeRange) *string { return v.EndIp }).(pulumi.StringPtrOutput)
}

// ID.
func (o Phase1Ipv6ExcludeRangeOutput) Id() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Phase1Ipv6ExcludeRange) *int { return v.Id }).(pulumi.IntPtrOutput)
}

// Start of IPv6 exclusive range.
func (o Phase1Ipv6ExcludeRangeOutput) StartIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1Ipv6ExcludeRange) *string { return v.StartIp }).(pulumi.StringPtrOutput)
}

type Phase1Ipv6ExcludeRangeArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1Ipv6ExcludeRangeArrayOutput) ToPhase1Ipv6ExcludeRangeArrayOutput() Phase1Ipv6ExcludeRangeArrayOutput {
	return o
}

func (o Phase1Ipv6ExcludeRangeArrayOutput) ToPhase1Ipv6ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1Ipv6ExcludeRangeArrayOutput {
	return o
}

func (o Phase1Ipv6ExcludeRangeArrayOutput) Index(i pulumi.IntInput) Phase1Ipv6ExcludeRangeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1Ipv6ExcludeRange {
		return vs[0].([]Phase1Ipv6ExcludeRange)[vs[1].(int)]
	}).(Phase1Ipv6ExcludeRangeOutput)
}

type Phase1interfaceBackupGateway struct {
	// Address of backup gateway.
	Address *string `pulumi:"address"`
}

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

	ToPhase1interfaceBackupGatewayOutput() Phase1interfaceBackupGatewayOutput
	ToPhase1interfaceBackupGatewayOutputWithContext(context.Context) Phase1interfaceBackupGatewayOutput
}

type Phase1interfaceBackupGatewayArgs struct {
	// Address of backup gateway.
	Address pulumi.StringPtrInput `pulumi:"address"`
}

func (Phase1interfaceBackupGatewayArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceBackupGateway)(nil)).Elem()
}

func (i Phase1interfaceBackupGatewayArgs) ToPhase1interfaceBackupGatewayOutput() Phase1interfaceBackupGatewayOutput {
	return i.ToPhase1interfaceBackupGatewayOutputWithContext(context.Background())
}

func (i Phase1interfaceBackupGatewayArgs) ToPhase1interfaceBackupGatewayOutputWithContext(ctx context.Context) Phase1interfaceBackupGatewayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceBackupGatewayOutput)
}

// Phase1interfaceBackupGatewayArrayInput is an input type that accepts Phase1interfaceBackupGatewayArray and Phase1interfaceBackupGatewayArrayOutput values.
// You can construct a concrete instance of `Phase1interfaceBackupGatewayArrayInput` via:
//
//	Phase1interfaceBackupGatewayArray{ Phase1interfaceBackupGatewayArgs{...} }
type Phase1interfaceBackupGatewayArrayInput interface {
	pulumi.Input

	ToPhase1interfaceBackupGatewayArrayOutput() Phase1interfaceBackupGatewayArrayOutput
	ToPhase1interfaceBackupGatewayArrayOutputWithContext(context.Context) Phase1interfaceBackupGatewayArrayOutput
}

type Phase1interfaceBackupGatewayArray []Phase1interfaceBackupGatewayInput

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

func (i Phase1interfaceBackupGatewayArray) ToPhase1interfaceBackupGatewayArrayOutput() Phase1interfaceBackupGatewayArrayOutput {
	return i.ToPhase1interfaceBackupGatewayArrayOutputWithContext(context.Background())
}

func (i Phase1interfaceBackupGatewayArray) ToPhase1interfaceBackupGatewayArrayOutputWithContext(ctx context.Context) Phase1interfaceBackupGatewayArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceBackupGatewayArrayOutput)
}

type Phase1interfaceBackupGatewayOutput struct{ *pulumi.OutputState }

func (Phase1interfaceBackupGatewayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceBackupGateway)(nil)).Elem()
}

func (o Phase1interfaceBackupGatewayOutput) ToPhase1interfaceBackupGatewayOutput() Phase1interfaceBackupGatewayOutput {
	return o
}

func (o Phase1interfaceBackupGatewayOutput) ToPhase1interfaceBackupGatewayOutputWithContext(ctx context.Context) Phase1interfaceBackupGatewayOutput {
	return o
}

// Address of backup gateway.
func (o Phase1interfaceBackupGatewayOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceBackupGateway) *string { return v.Address }).(pulumi.StringPtrOutput)
}

type Phase1interfaceBackupGatewayArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1interfaceBackupGatewayArrayOutput) ToPhase1interfaceBackupGatewayArrayOutput() Phase1interfaceBackupGatewayArrayOutput {
	return o
}

func (o Phase1interfaceBackupGatewayArrayOutput) ToPhase1interfaceBackupGatewayArrayOutputWithContext(ctx context.Context) Phase1interfaceBackupGatewayArrayOutput {
	return o
}

func (o Phase1interfaceBackupGatewayArrayOutput) Index(i pulumi.IntInput) Phase1interfaceBackupGatewayOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1interfaceBackupGateway {
		return vs[0].([]Phase1interfaceBackupGateway)[vs[1].(int)]
	}).(Phase1interfaceBackupGatewayOutput)
}

type Phase1interfaceCertificate struct {
	// Certificate name.
	Name *string `pulumi:"name"`
}

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

	ToPhase1interfaceCertificateOutput() Phase1interfaceCertificateOutput
	ToPhase1interfaceCertificateOutputWithContext(context.Context) Phase1interfaceCertificateOutput
}

type Phase1interfaceCertificateArgs struct {
	// Certificate name.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

func (Phase1interfaceCertificateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceCertificate)(nil)).Elem()
}

func (i Phase1interfaceCertificateArgs) ToPhase1interfaceCertificateOutput() Phase1interfaceCertificateOutput {
	return i.ToPhase1interfaceCertificateOutputWithContext(context.Background())
}

func (i Phase1interfaceCertificateArgs) ToPhase1interfaceCertificateOutputWithContext(ctx context.Context) Phase1interfaceCertificateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceCertificateOutput)
}

// Phase1interfaceCertificateArrayInput is an input type that accepts Phase1interfaceCertificateArray and Phase1interfaceCertificateArrayOutput values.
// You can construct a concrete instance of `Phase1interfaceCertificateArrayInput` via:
//
//	Phase1interfaceCertificateArray{ Phase1interfaceCertificateArgs{...} }
type Phase1interfaceCertificateArrayInput interface {
	pulumi.Input

	ToPhase1interfaceCertificateArrayOutput() Phase1interfaceCertificateArrayOutput
	ToPhase1interfaceCertificateArrayOutputWithContext(context.Context) Phase1interfaceCertificateArrayOutput
}

type Phase1interfaceCertificateArray []Phase1interfaceCertificateInput

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

func (i Phase1interfaceCertificateArray) ToPhase1interfaceCertificateArrayOutput() Phase1interfaceCertificateArrayOutput {
	return i.ToPhase1interfaceCertificateArrayOutputWithContext(context.Background())
}

func (i Phase1interfaceCertificateArray) ToPhase1interfaceCertificateArrayOutputWithContext(ctx context.Context) Phase1interfaceCertificateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceCertificateArrayOutput)
}

type Phase1interfaceCertificateOutput struct{ *pulumi.OutputState }

func (Phase1interfaceCertificateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceCertificate)(nil)).Elem()
}

func (o Phase1interfaceCertificateOutput) ToPhase1interfaceCertificateOutput() Phase1interfaceCertificateOutput {
	return o
}

func (o Phase1interfaceCertificateOutput) ToPhase1interfaceCertificateOutputWithContext(ctx context.Context) Phase1interfaceCertificateOutput {
	return o
}

// Certificate name.
func (o Phase1interfaceCertificateOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceCertificate) *string { return v.Name }).(pulumi.StringPtrOutput)
}

type Phase1interfaceCertificateArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1interfaceCertificateArrayOutput) ToPhase1interfaceCertificateArrayOutput() Phase1interfaceCertificateArrayOutput {
	return o
}

func (o Phase1interfaceCertificateArrayOutput) ToPhase1interfaceCertificateArrayOutputWithContext(ctx context.Context) Phase1interfaceCertificateArrayOutput {
	return o
}

func (o Phase1interfaceCertificateArrayOutput) Index(i pulumi.IntInput) Phase1interfaceCertificateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1interfaceCertificate {
		return vs[0].([]Phase1interfaceCertificate)[vs[1].(int)]
	}).(Phase1interfaceCertificateOutput)
}

type Phase1interfaceInternalDomainList struct {
	// Domain name.
	//
	// The `ipv4ExcludeRange` block supports:
	DomainName *string `pulumi:"domainName"`
}

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

	ToPhase1interfaceInternalDomainListOutput() Phase1interfaceInternalDomainListOutput
	ToPhase1interfaceInternalDomainListOutputWithContext(context.Context) Phase1interfaceInternalDomainListOutput
}

type Phase1interfaceInternalDomainListArgs struct {
	// Domain name.
	//
	// The `ipv4ExcludeRange` block supports:
	DomainName pulumi.StringPtrInput `pulumi:"domainName"`
}

func (Phase1interfaceInternalDomainListArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceInternalDomainList)(nil)).Elem()
}

func (i Phase1interfaceInternalDomainListArgs) ToPhase1interfaceInternalDomainListOutput() Phase1interfaceInternalDomainListOutput {
	return i.ToPhase1interfaceInternalDomainListOutputWithContext(context.Background())
}

func (i Phase1interfaceInternalDomainListArgs) ToPhase1interfaceInternalDomainListOutputWithContext(ctx context.Context) Phase1interfaceInternalDomainListOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceInternalDomainListOutput)
}

// Phase1interfaceInternalDomainListArrayInput is an input type that accepts Phase1interfaceInternalDomainListArray and Phase1interfaceInternalDomainListArrayOutput values.
// You can construct a concrete instance of `Phase1interfaceInternalDomainListArrayInput` via:
//
//	Phase1interfaceInternalDomainListArray{ Phase1interfaceInternalDomainListArgs{...} }
type Phase1interfaceInternalDomainListArrayInput interface {
	pulumi.Input

	ToPhase1interfaceInternalDomainListArrayOutput() Phase1interfaceInternalDomainListArrayOutput
	ToPhase1interfaceInternalDomainListArrayOutputWithContext(context.Context) Phase1interfaceInternalDomainListArrayOutput
}

type Phase1interfaceInternalDomainListArray []Phase1interfaceInternalDomainListInput

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

func (i Phase1interfaceInternalDomainListArray) ToPhase1interfaceInternalDomainListArrayOutput() Phase1interfaceInternalDomainListArrayOutput {
	return i.ToPhase1interfaceInternalDomainListArrayOutputWithContext(context.Background())
}

func (i Phase1interfaceInternalDomainListArray) ToPhase1interfaceInternalDomainListArrayOutputWithContext(ctx context.Context) Phase1interfaceInternalDomainListArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceInternalDomainListArrayOutput)
}

type Phase1interfaceInternalDomainListOutput struct{ *pulumi.OutputState }

func (Phase1interfaceInternalDomainListOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceInternalDomainList)(nil)).Elem()
}

func (o Phase1interfaceInternalDomainListOutput) ToPhase1interfaceInternalDomainListOutput() Phase1interfaceInternalDomainListOutput {
	return o
}

func (o Phase1interfaceInternalDomainListOutput) ToPhase1interfaceInternalDomainListOutputWithContext(ctx context.Context) Phase1interfaceInternalDomainListOutput {
	return o
}

// Domain name.
//
// The `ipv4ExcludeRange` block supports:
func (o Phase1interfaceInternalDomainListOutput) DomainName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceInternalDomainList) *string { return v.DomainName }).(pulumi.StringPtrOutput)
}

type Phase1interfaceInternalDomainListArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1interfaceInternalDomainListArrayOutput) ToPhase1interfaceInternalDomainListArrayOutput() Phase1interfaceInternalDomainListArrayOutput {
	return o
}

func (o Phase1interfaceInternalDomainListArrayOutput) ToPhase1interfaceInternalDomainListArrayOutputWithContext(ctx context.Context) Phase1interfaceInternalDomainListArrayOutput {
	return o
}

func (o Phase1interfaceInternalDomainListArrayOutput) Index(i pulumi.IntInput) Phase1interfaceInternalDomainListOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1interfaceInternalDomainList {
		return vs[0].([]Phase1interfaceInternalDomainList)[vs[1].(int)]
	}).(Phase1interfaceInternalDomainListOutput)
}

type Phase1interfaceIpv4ExcludeRange struct {
	// End of IPv6 exclusive range.
	EndIp *string `pulumi:"endIp"`
	// ID.
	Id *int `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp *string `pulumi:"startIp"`
}

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

	ToPhase1interfaceIpv4ExcludeRangeOutput() Phase1interfaceIpv4ExcludeRangeOutput
	ToPhase1interfaceIpv4ExcludeRangeOutputWithContext(context.Context) Phase1interfaceIpv4ExcludeRangeOutput
}

type Phase1interfaceIpv4ExcludeRangeArgs struct {
	// End of IPv6 exclusive range.
	EndIp pulumi.StringPtrInput `pulumi:"endIp"`
	// ID.
	Id pulumi.IntPtrInput `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp pulumi.StringPtrInput `pulumi:"startIp"`
}

func (Phase1interfaceIpv4ExcludeRangeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceIpv4ExcludeRange)(nil)).Elem()
}

func (i Phase1interfaceIpv4ExcludeRangeArgs) ToPhase1interfaceIpv4ExcludeRangeOutput() Phase1interfaceIpv4ExcludeRangeOutput {
	return i.ToPhase1interfaceIpv4ExcludeRangeOutputWithContext(context.Background())
}

func (i Phase1interfaceIpv4ExcludeRangeArgs) ToPhase1interfaceIpv4ExcludeRangeOutputWithContext(ctx context.Context) Phase1interfaceIpv4ExcludeRangeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceIpv4ExcludeRangeOutput)
}

// Phase1interfaceIpv4ExcludeRangeArrayInput is an input type that accepts Phase1interfaceIpv4ExcludeRangeArray and Phase1interfaceIpv4ExcludeRangeArrayOutput values.
// You can construct a concrete instance of `Phase1interfaceIpv4ExcludeRangeArrayInput` via:
//
//	Phase1interfaceIpv4ExcludeRangeArray{ Phase1interfaceIpv4ExcludeRangeArgs{...} }
type Phase1interfaceIpv4ExcludeRangeArrayInput interface {
	pulumi.Input

	ToPhase1interfaceIpv4ExcludeRangeArrayOutput() Phase1interfaceIpv4ExcludeRangeArrayOutput
	ToPhase1interfaceIpv4ExcludeRangeArrayOutputWithContext(context.Context) Phase1interfaceIpv4ExcludeRangeArrayOutput
}

type Phase1interfaceIpv4ExcludeRangeArray []Phase1interfaceIpv4ExcludeRangeInput

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

func (i Phase1interfaceIpv4ExcludeRangeArray) ToPhase1interfaceIpv4ExcludeRangeArrayOutput() Phase1interfaceIpv4ExcludeRangeArrayOutput {
	return i.ToPhase1interfaceIpv4ExcludeRangeArrayOutputWithContext(context.Background())
}

func (i Phase1interfaceIpv4ExcludeRangeArray) ToPhase1interfaceIpv4ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1interfaceIpv4ExcludeRangeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceIpv4ExcludeRangeArrayOutput)
}

type Phase1interfaceIpv4ExcludeRangeOutput struct{ *pulumi.OutputState }

func (Phase1interfaceIpv4ExcludeRangeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceIpv4ExcludeRange)(nil)).Elem()
}

func (o Phase1interfaceIpv4ExcludeRangeOutput) ToPhase1interfaceIpv4ExcludeRangeOutput() Phase1interfaceIpv4ExcludeRangeOutput {
	return o
}

func (o Phase1interfaceIpv4ExcludeRangeOutput) ToPhase1interfaceIpv4ExcludeRangeOutputWithContext(ctx context.Context) Phase1interfaceIpv4ExcludeRangeOutput {
	return o
}

// End of IPv6 exclusive range.
func (o Phase1interfaceIpv4ExcludeRangeOutput) EndIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv4ExcludeRange) *string { return v.EndIp }).(pulumi.StringPtrOutput)
}

// ID.
func (o Phase1interfaceIpv4ExcludeRangeOutput) Id() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv4ExcludeRange) *int { return v.Id }).(pulumi.IntPtrOutput)
}

// Start of IPv6 exclusive range.
func (o Phase1interfaceIpv4ExcludeRangeOutput) StartIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv4ExcludeRange) *string { return v.StartIp }).(pulumi.StringPtrOutput)
}

type Phase1interfaceIpv4ExcludeRangeArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1interfaceIpv4ExcludeRangeArrayOutput) ToPhase1interfaceIpv4ExcludeRangeArrayOutput() Phase1interfaceIpv4ExcludeRangeArrayOutput {
	return o
}

func (o Phase1interfaceIpv4ExcludeRangeArrayOutput) ToPhase1interfaceIpv4ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1interfaceIpv4ExcludeRangeArrayOutput {
	return o
}

func (o Phase1interfaceIpv4ExcludeRangeArrayOutput) Index(i pulumi.IntInput) Phase1interfaceIpv4ExcludeRangeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1interfaceIpv4ExcludeRange {
		return vs[0].([]Phase1interfaceIpv4ExcludeRange)[vs[1].(int)]
	}).(Phase1interfaceIpv4ExcludeRangeOutput)
}

type Phase1interfaceIpv6ExcludeRange struct {
	// End of IPv6 exclusive range.
	EndIp *string `pulumi:"endIp"`
	// ID.
	Id *int `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp *string `pulumi:"startIp"`
}

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

	ToPhase1interfaceIpv6ExcludeRangeOutput() Phase1interfaceIpv6ExcludeRangeOutput
	ToPhase1interfaceIpv6ExcludeRangeOutputWithContext(context.Context) Phase1interfaceIpv6ExcludeRangeOutput
}

type Phase1interfaceIpv6ExcludeRangeArgs struct {
	// End of IPv6 exclusive range.
	EndIp pulumi.StringPtrInput `pulumi:"endIp"`
	// ID.
	Id pulumi.IntPtrInput `pulumi:"id"`
	// Start of IPv6 exclusive range.
	StartIp pulumi.StringPtrInput `pulumi:"startIp"`
}

func (Phase1interfaceIpv6ExcludeRangeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceIpv6ExcludeRange)(nil)).Elem()
}

func (i Phase1interfaceIpv6ExcludeRangeArgs) ToPhase1interfaceIpv6ExcludeRangeOutput() Phase1interfaceIpv6ExcludeRangeOutput {
	return i.ToPhase1interfaceIpv6ExcludeRangeOutputWithContext(context.Background())
}

func (i Phase1interfaceIpv6ExcludeRangeArgs) ToPhase1interfaceIpv6ExcludeRangeOutputWithContext(ctx context.Context) Phase1interfaceIpv6ExcludeRangeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceIpv6ExcludeRangeOutput)
}

// Phase1interfaceIpv6ExcludeRangeArrayInput is an input type that accepts Phase1interfaceIpv6ExcludeRangeArray and Phase1interfaceIpv6ExcludeRangeArrayOutput values.
// You can construct a concrete instance of `Phase1interfaceIpv6ExcludeRangeArrayInput` via:
//
//	Phase1interfaceIpv6ExcludeRangeArray{ Phase1interfaceIpv6ExcludeRangeArgs{...} }
type Phase1interfaceIpv6ExcludeRangeArrayInput interface {
	pulumi.Input

	ToPhase1interfaceIpv6ExcludeRangeArrayOutput() Phase1interfaceIpv6ExcludeRangeArrayOutput
	ToPhase1interfaceIpv6ExcludeRangeArrayOutputWithContext(context.Context) Phase1interfaceIpv6ExcludeRangeArrayOutput
}

type Phase1interfaceIpv6ExcludeRangeArray []Phase1interfaceIpv6ExcludeRangeInput

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

func (i Phase1interfaceIpv6ExcludeRangeArray) ToPhase1interfaceIpv6ExcludeRangeArrayOutput() Phase1interfaceIpv6ExcludeRangeArrayOutput {
	return i.ToPhase1interfaceIpv6ExcludeRangeArrayOutputWithContext(context.Background())
}

func (i Phase1interfaceIpv6ExcludeRangeArray) ToPhase1interfaceIpv6ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1interfaceIpv6ExcludeRangeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(Phase1interfaceIpv6ExcludeRangeArrayOutput)
}

type Phase1interfaceIpv6ExcludeRangeOutput struct{ *pulumi.OutputState }

func (Phase1interfaceIpv6ExcludeRangeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Phase1interfaceIpv6ExcludeRange)(nil)).Elem()
}

func (o Phase1interfaceIpv6ExcludeRangeOutput) ToPhase1interfaceIpv6ExcludeRangeOutput() Phase1interfaceIpv6ExcludeRangeOutput {
	return o
}

func (o Phase1interfaceIpv6ExcludeRangeOutput) ToPhase1interfaceIpv6ExcludeRangeOutputWithContext(ctx context.Context) Phase1interfaceIpv6ExcludeRangeOutput {
	return o
}

// End of IPv6 exclusive range.
func (o Phase1interfaceIpv6ExcludeRangeOutput) EndIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv6ExcludeRange) *string { return v.EndIp }).(pulumi.StringPtrOutput)
}

// ID.
func (o Phase1interfaceIpv6ExcludeRangeOutput) Id() pulumi.IntPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv6ExcludeRange) *int { return v.Id }).(pulumi.IntPtrOutput)
}

// Start of IPv6 exclusive range.
func (o Phase1interfaceIpv6ExcludeRangeOutput) StartIp() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Phase1interfaceIpv6ExcludeRange) *string { return v.StartIp }).(pulumi.StringPtrOutput)
}

type Phase1interfaceIpv6ExcludeRangeArrayOutput struct{ *pulumi.OutputState }

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

func (o Phase1interfaceIpv6ExcludeRangeArrayOutput) ToPhase1interfaceIpv6ExcludeRangeArrayOutput() Phase1interfaceIpv6ExcludeRangeArrayOutput {
	return o
}

func (o Phase1interfaceIpv6ExcludeRangeArrayOutput) ToPhase1interfaceIpv6ExcludeRangeArrayOutputWithContext(ctx context.Context) Phase1interfaceIpv6ExcludeRangeArrayOutput {
	return o
}

func (o Phase1interfaceIpv6ExcludeRangeArrayOutput) Index(i pulumi.IntInput) Phase1interfaceIpv6ExcludeRangeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Phase1interfaceIpv6ExcludeRange {
		return vs[0].([]Phase1interfaceIpv6ExcludeRange)[vs[1].(int)]
	}).(Phase1interfaceIpv6ExcludeRangeOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ConcentratorMemberInput)(nil)).Elem(), ConcentratorMemberArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConcentratorMemberArrayInput)(nil)).Elem(), ConcentratorMemberArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*FecMappingInput)(nil)).Elem(), FecMappingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FecMappingArrayInput)(nil)).Elem(), FecMappingArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1BackupGatewayInput)(nil)).Elem(), Phase1BackupGatewayArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1BackupGatewayArrayInput)(nil)).Elem(), Phase1BackupGatewayArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1CertificateInput)(nil)).Elem(), Phase1CertificateArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1CertificateArrayInput)(nil)).Elem(), Phase1CertificateArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1InternalDomainListInput)(nil)).Elem(), Phase1InternalDomainListArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1InternalDomainListArrayInput)(nil)).Elem(), Phase1InternalDomainListArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1Ipv4ExcludeRangeInput)(nil)).Elem(), Phase1Ipv4ExcludeRangeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1Ipv4ExcludeRangeArrayInput)(nil)).Elem(), Phase1Ipv4ExcludeRangeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1Ipv6ExcludeRangeInput)(nil)).Elem(), Phase1Ipv6ExcludeRangeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1Ipv6ExcludeRangeArrayInput)(nil)).Elem(), Phase1Ipv6ExcludeRangeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceBackupGatewayInput)(nil)).Elem(), Phase1interfaceBackupGatewayArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceBackupGatewayArrayInput)(nil)).Elem(), Phase1interfaceBackupGatewayArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceCertificateInput)(nil)).Elem(), Phase1interfaceCertificateArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceCertificateArrayInput)(nil)).Elem(), Phase1interfaceCertificateArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceInternalDomainListInput)(nil)).Elem(), Phase1interfaceInternalDomainListArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceInternalDomainListArrayInput)(nil)).Elem(), Phase1interfaceInternalDomainListArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceIpv4ExcludeRangeInput)(nil)).Elem(), Phase1interfaceIpv4ExcludeRangeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceIpv4ExcludeRangeArrayInput)(nil)).Elem(), Phase1interfaceIpv4ExcludeRangeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceIpv6ExcludeRangeInput)(nil)).Elem(), Phase1interfaceIpv6ExcludeRangeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*Phase1interfaceIpv6ExcludeRangeArrayInput)(nil)).Elem(), Phase1interfaceIpv6ExcludeRangeArray{})
	pulumi.RegisterOutputType(ConcentratorMemberOutput{})
	pulumi.RegisterOutputType(ConcentratorMemberArrayOutput{})
	pulumi.RegisterOutputType(FecMappingOutput{})
	pulumi.RegisterOutputType(FecMappingArrayOutput{})
	pulumi.RegisterOutputType(Phase1BackupGatewayOutput{})
	pulumi.RegisterOutputType(Phase1BackupGatewayArrayOutput{})
	pulumi.RegisterOutputType(Phase1CertificateOutput{})
	pulumi.RegisterOutputType(Phase1CertificateArrayOutput{})
	pulumi.RegisterOutputType(Phase1InternalDomainListOutput{})
	pulumi.RegisterOutputType(Phase1InternalDomainListArrayOutput{})
	pulumi.RegisterOutputType(Phase1Ipv4ExcludeRangeOutput{})
	pulumi.RegisterOutputType(Phase1Ipv4ExcludeRangeArrayOutput{})
	pulumi.RegisterOutputType(Phase1Ipv6ExcludeRangeOutput{})
	pulumi.RegisterOutputType(Phase1Ipv6ExcludeRangeArrayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceBackupGatewayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceBackupGatewayArrayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceCertificateOutput{})
	pulumi.RegisterOutputType(Phase1interfaceCertificateArrayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceInternalDomainListOutput{})
	pulumi.RegisterOutputType(Phase1interfaceInternalDomainListArrayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceIpv4ExcludeRangeOutput{})
	pulumi.RegisterOutputType(Phase1interfaceIpv4ExcludeRangeArrayOutput{})
	pulumi.RegisterOutputType(Phase1interfaceIpv6ExcludeRangeOutput{})
	pulumi.RegisterOutputType(Phase1interfaceIpv6ExcludeRangeArrayOutput{})
}