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

package v1alpha1

import (
	"context"
	"reflect"

	"antoine-roux.tk/projects/go/pulumi-library/crds/kubernetes/internal"
	v1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

var _ = internal.GetEnvOrDefault

type DNSEndpointType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// DNSEndpointSpec defines the desired state of DNSEndpoint
	Spec *DNSEndpointSpec `pulumi:"spec"`
	// DNSEndpointStatus defines the observed state of DNSEndpoint
	Status *DNSEndpointStatus `pulumi:"status"`
}

type DNSEndpointMetadata struct {
}

// DNSEndpointSpec defines the desired state of DNSEndpoint
type DNSEndpointSpec struct {
	Endpoints []DNSEndpointSpecEndpoints `pulumi:"endpoints"`
}

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

	ToDNSEndpointSpecOutput() DNSEndpointSpecOutput
	ToDNSEndpointSpecOutputWithContext(context.Context) DNSEndpointSpecOutput
}

// DNSEndpointSpec defines the desired state of DNSEndpoint
type DNSEndpointSpecArgs struct {
	Endpoints DNSEndpointSpecEndpointsArrayInput `pulumi:"endpoints"`
}

func (DNSEndpointSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpec)(nil)).Elem()
}

func (i DNSEndpointSpecArgs) ToDNSEndpointSpecOutput() DNSEndpointSpecOutput {
	return i.ToDNSEndpointSpecOutputWithContext(context.Background())
}

func (i DNSEndpointSpecArgs) ToDNSEndpointSpecOutputWithContext(ctx context.Context) DNSEndpointSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecOutput)
}

func (i DNSEndpointSpecArgs) ToOutput(ctx context.Context) pulumix.Output[DNSEndpointSpec] {
	return pulumix.Output[DNSEndpointSpec]{
		OutputState: i.ToDNSEndpointSpecOutputWithContext(ctx).OutputState,
	}
}

func (i DNSEndpointSpecArgs) ToDNSEndpointSpecPtrOutput() DNSEndpointSpecPtrOutput {
	return i.ToDNSEndpointSpecPtrOutputWithContext(context.Background())
}

func (i DNSEndpointSpecArgs) ToDNSEndpointSpecPtrOutputWithContext(ctx context.Context) DNSEndpointSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecOutput).ToDNSEndpointSpecPtrOutputWithContext(ctx)
}

// DNSEndpointSpecPtrInput is an input type that accepts DNSEndpointSpecArgs, DNSEndpointSpecPtr and DNSEndpointSpecPtrOutput values.
// You can construct a concrete instance of `DNSEndpointSpecPtrInput` via:
//
//	        DNSEndpointSpecArgs{...}
//
//	or:
//
//	        nil
type DNSEndpointSpecPtrInput interface {
	pulumi.Input

	ToDNSEndpointSpecPtrOutput() DNSEndpointSpecPtrOutput
	ToDNSEndpointSpecPtrOutputWithContext(context.Context) DNSEndpointSpecPtrOutput
}

type dnsendpointSpecPtrType DNSEndpointSpecArgs

func DNSEndpointSpecPtr(v *DNSEndpointSpecArgs) DNSEndpointSpecPtrInput {
	return (*dnsendpointSpecPtrType)(v)
}

func (*dnsendpointSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DNSEndpointSpec)(nil)).Elem()
}

func (i *dnsendpointSpecPtrType) ToDNSEndpointSpecPtrOutput() DNSEndpointSpecPtrOutput {
	return i.ToDNSEndpointSpecPtrOutputWithContext(context.Background())
}

func (i *dnsendpointSpecPtrType) ToDNSEndpointSpecPtrOutputWithContext(ctx context.Context) DNSEndpointSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecPtrOutput)
}

func (i *dnsendpointSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*DNSEndpointSpec] {
	return pulumix.Output[*DNSEndpointSpec]{
		OutputState: i.ToDNSEndpointSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// DNSEndpointSpec defines the desired state of DNSEndpoint
type DNSEndpointSpecOutput struct{ *pulumi.OutputState }

func (DNSEndpointSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpec)(nil)).Elem()
}

func (o DNSEndpointSpecOutput) ToDNSEndpointSpecOutput() DNSEndpointSpecOutput {
	return o
}

func (o DNSEndpointSpecOutput) ToDNSEndpointSpecOutputWithContext(ctx context.Context) DNSEndpointSpecOutput {
	return o
}

func (o DNSEndpointSpecOutput) ToDNSEndpointSpecPtrOutput() DNSEndpointSpecPtrOutput {
	return o.ToDNSEndpointSpecPtrOutputWithContext(context.Background())
}

func (o DNSEndpointSpecOutput) ToDNSEndpointSpecPtrOutputWithContext(ctx context.Context) DNSEndpointSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DNSEndpointSpec) *DNSEndpointSpec {
		return &v
	}).(DNSEndpointSpecPtrOutput)
}

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

func (o DNSEndpointSpecOutput) Endpoints() DNSEndpointSpecEndpointsArrayOutput {
	return o.ApplyT(func(v DNSEndpointSpec) []DNSEndpointSpecEndpoints { return v.Endpoints }).(DNSEndpointSpecEndpointsArrayOutput)
}

type DNSEndpointSpecPtrOutput struct{ *pulumi.OutputState }

func (DNSEndpointSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DNSEndpointSpec)(nil)).Elem()
}

func (o DNSEndpointSpecPtrOutput) ToDNSEndpointSpecPtrOutput() DNSEndpointSpecPtrOutput {
	return o
}

func (o DNSEndpointSpecPtrOutput) ToDNSEndpointSpecPtrOutputWithContext(ctx context.Context) DNSEndpointSpecPtrOutput {
	return o
}

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

func (o DNSEndpointSpecPtrOutput) Elem() DNSEndpointSpecOutput {
	return o.ApplyT(func(v *DNSEndpointSpec) DNSEndpointSpec {
		if v != nil {
			return *v
		}
		var ret DNSEndpointSpec
		return ret
	}).(DNSEndpointSpecOutput)
}

func (o DNSEndpointSpecPtrOutput) Endpoints() DNSEndpointSpecEndpointsArrayOutput {
	return o.ApplyT(func(v *DNSEndpointSpec) []DNSEndpointSpecEndpoints {
		if v == nil {
			return nil
		}
		return v.Endpoints
	}).(DNSEndpointSpecEndpointsArrayOutput)
}

// Endpoint is a high-level way of a connection between a service and an IP
type DNSEndpointSpecEndpoints struct {
	// The hostname of the DNS record
	DnsName *string `pulumi:"dnsName"`
	// Labels stores labels defined for the Endpoint
	Labels map[string]string `pulumi:"labels"`
	// ProviderSpecific stores provider specific config
	ProviderSpecific []DNSEndpointSpecEndpointsProviderSpecific `pulumi:"providerSpecific"`
	// TTL for the record
	RecordTTL *int `pulumi:"recordTTL"`
	// RecordType type of record, e.g. CNAME, A, SRV, TXT etc
	RecordType *string `pulumi:"recordType"`
	// Identifier to distinguish multiple records with the same name and type (e.g. Route53 records with routing policies other than 'simple')
	SetIdentifier *string `pulumi:"setIdentifier"`
	// The targets the DNS record points to
	Targets []string `pulumi:"targets"`
}

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

	ToDNSEndpointSpecEndpointsOutput() DNSEndpointSpecEndpointsOutput
	ToDNSEndpointSpecEndpointsOutputWithContext(context.Context) DNSEndpointSpecEndpointsOutput
}

// Endpoint is a high-level way of a connection between a service and an IP
type DNSEndpointSpecEndpointsArgs struct {
	// The hostname of the DNS record
	DnsName pulumi.StringPtrInput `pulumi:"dnsName"`
	// Labels stores labels defined for the Endpoint
	Labels pulumi.StringMapInput `pulumi:"labels"`
	// ProviderSpecific stores provider specific config
	ProviderSpecific DNSEndpointSpecEndpointsProviderSpecificArrayInput `pulumi:"providerSpecific"`
	// TTL for the record
	RecordTTL pulumi.IntPtrInput `pulumi:"recordTTL"`
	// RecordType type of record, e.g. CNAME, A, SRV, TXT etc
	RecordType pulumi.StringPtrInput `pulumi:"recordType"`
	// Identifier to distinguish multiple records with the same name and type (e.g. Route53 records with routing policies other than 'simple')
	SetIdentifier pulumi.StringPtrInput `pulumi:"setIdentifier"`
	// The targets the DNS record points to
	Targets pulumi.StringArrayInput `pulumi:"targets"`
}

func (DNSEndpointSpecEndpointsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpecEndpoints)(nil)).Elem()
}

func (i DNSEndpointSpecEndpointsArgs) ToDNSEndpointSpecEndpointsOutput() DNSEndpointSpecEndpointsOutput {
	return i.ToDNSEndpointSpecEndpointsOutputWithContext(context.Background())
}

func (i DNSEndpointSpecEndpointsArgs) ToDNSEndpointSpecEndpointsOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecEndpointsOutput)
}

func (i DNSEndpointSpecEndpointsArgs) ToOutput(ctx context.Context) pulumix.Output[DNSEndpointSpecEndpoints] {
	return pulumix.Output[DNSEndpointSpecEndpoints]{
		OutputState: i.ToDNSEndpointSpecEndpointsOutputWithContext(ctx).OutputState,
	}
}

// DNSEndpointSpecEndpointsArrayInput is an input type that accepts DNSEndpointSpecEndpointsArray and DNSEndpointSpecEndpointsArrayOutput values.
// You can construct a concrete instance of `DNSEndpointSpecEndpointsArrayInput` via:
//
//	DNSEndpointSpecEndpointsArray{ DNSEndpointSpecEndpointsArgs{...} }
type DNSEndpointSpecEndpointsArrayInput interface {
	pulumi.Input

	ToDNSEndpointSpecEndpointsArrayOutput() DNSEndpointSpecEndpointsArrayOutput
	ToDNSEndpointSpecEndpointsArrayOutputWithContext(context.Context) DNSEndpointSpecEndpointsArrayOutput
}

type DNSEndpointSpecEndpointsArray []DNSEndpointSpecEndpointsInput

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

func (i DNSEndpointSpecEndpointsArray) ToDNSEndpointSpecEndpointsArrayOutput() DNSEndpointSpecEndpointsArrayOutput {
	return i.ToDNSEndpointSpecEndpointsArrayOutputWithContext(context.Background())
}

func (i DNSEndpointSpecEndpointsArray) ToDNSEndpointSpecEndpointsArrayOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecEndpointsArrayOutput)
}

func (i DNSEndpointSpecEndpointsArray) ToOutput(ctx context.Context) pulumix.Output[[]DNSEndpointSpecEndpoints] {
	return pulumix.Output[[]DNSEndpointSpecEndpoints]{
		OutputState: i.ToDNSEndpointSpecEndpointsArrayOutputWithContext(ctx).OutputState,
	}
}

// Endpoint is a high-level way of a connection between a service and an IP
type DNSEndpointSpecEndpointsOutput struct{ *pulumi.OutputState }

func (DNSEndpointSpecEndpointsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpecEndpoints)(nil)).Elem()
}

func (o DNSEndpointSpecEndpointsOutput) ToDNSEndpointSpecEndpointsOutput() DNSEndpointSpecEndpointsOutput {
	return o
}

func (o DNSEndpointSpecEndpointsOutput) ToDNSEndpointSpecEndpointsOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsOutput {
	return o
}

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

// The hostname of the DNS record
func (o DNSEndpointSpecEndpointsOutput) DnsName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) *string { return v.DnsName }).(pulumi.StringPtrOutput)
}

// Labels stores labels defined for the Endpoint
func (o DNSEndpointSpecEndpointsOutput) Labels() pulumi.StringMapOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) map[string]string { return v.Labels }).(pulumi.StringMapOutput)
}

// ProviderSpecific stores provider specific config
func (o DNSEndpointSpecEndpointsOutput) ProviderSpecific() DNSEndpointSpecEndpointsProviderSpecificArrayOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) []DNSEndpointSpecEndpointsProviderSpecific { return v.ProviderSpecific }).(DNSEndpointSpecEndpointsProviderSpecificArrayOutput)
}

// TTL for the record
func (o DNSEndpointSpecEndpointsOutput) RecordTTL() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) *int { return v.RecordTTL }).(pulumi.IntPtrOutput)
}

// RecordType type of record, e.g. CNAME, A, SRV, TXT etc
func (o DNSEndpointSpecEndpointsOutput) RecordType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) *string { return v.RecordType }).(pulumi.StringPtrOutput)
}

// Identifier to distinguish multiple records with the same name and type (e.g. Route53 records with routing policies other than 'simple')
func (o DNSEndpointSpecEndpointsOutput) SetIdentifier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) *string { return v.SetIdentifier }).(pulumi.StringPtrOutput)
}

// The targets the DNS record points to
func (o DNSEndpointSpecEndpointsOutput) Targets() pulumi.StringArrayOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpoints) []string { return v.Targets }).(pulumi.StringArrayOutput)
}

type DNSEndpointSpecEndpointsArrayOutput struct{ *pulumi.OutputState }

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

func (o DNSEndpointSpecEndpointsArrayOutput) ToDNSEndpointSpecEndpointsArrayOutput() DNSEndpointSpecEndpointsArrayOutput {
	return o
}

func (o DNSEndpointSpecEndpointsArrayOutput) ToDNSEndpointSpecEndpointsArrayOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsArrayOutput {
	return o
}

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

func (o DNSEndpointSpecEndpointsArrayOutput) Index(i pulumi.IntInput) DNSEndpointSpecEndpointsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DNSEndpointSpecEndpoints {
		return vs[0].([]DNSEndpointSpecEndpoints)[vs[1].(int)]
	}).(DNSEndpointSpecEndpointsOutput)
}

// Labels stores labels defined for the Endpoint
type DNSEndpointSpecEndpointsLabels struct {
}

// ProviderSpecificProperty holds the name and value of a configuration which is specific to individual DNS providers
type DNSEndpointSpecEndpointsProviderSpecific struct {
	Name  *string `pulumi:"name"`
	Value *string `pulumi:"value"`
}

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

	ToDNSEndpointSpecEndpointsProviderSpecificOutput() DNSEndpointSpecEndpointsProviderSpecificOutput
	ToDNSEndpointSpecEndpointsProviderSpecificOutputWithContext(context.Context) DNSEndpointSpecEndpointsProviderSpecificOutput
}

// ProviderSpecificProperty holds the name and value of a configuration which is specific to individual DNS providers
type DNSEndpointSpecEndpointsProviderSpecificArgs struct {
	Name  pulumi.StringPtrInput `pulumi:"name"`
	Value pulumi.StringPtrInput `pulumi:"value"`
}

func (DNSEndpointSpecEndpointsProviderSpecificArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpecEndpointsProviderSpecific)(nil)).Elem()
}

func (i DNSEndpointSpecEndpointsProviderSpecificArgs) ToDNSEndpointSpecEndpointsProviderSpecificOutput() DNSEndpointSpecEndpointsProviderSpecificOutput {
	return i.ToDNSEndpointSpecEndpointsProviderSpecificOutputWithContext(context.Background())
}

func (i DNSEndpointSpecEndpointsProviderSpecificArgs) ToDNSEndpointSpecEndpointsProviderSpecificOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsProviderSpecificOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecEndpointsProviderSpecificOutput)
}

func (i DNSEndpointSpecEndpointsProviderSpecificArgs) ToOutput(ctx context.Context) pulumix.Output[DNSEndpointSpecEndpointsProviderSpecific] {
	return pulumix.Output[DNSEndpointSpecEndpointsProviderSpecific]{
		OutputState: i.ToDNSEndpointSpecEndpointsProviderSpecificOutputWithContext(ctx).OutputState,
	}
}

// DNSEndpointSpecEndpointsProviderSpecificArrayInput is an input type that accepts DNSEndpointSpecEndpointsProviderSpecificArray and DNSEndpointSpecEndpointsProviderSpecificArrayOutput values.
// You can construct a concrete instance of `DNSEndpointSpecEndpointsProviderSpecificArrayInput` via:
//
//	DNSEndpointSpecEndpointsProviderSpecificArray{ DNSEndpointSpecEndpointsProviderSpecificArgs{...} }
type DNSEndpointSpecEndpointsProviderSpecificArrayInput interface {
	pulumi.Input

	ToDNSEndpointSpecEndpointsProviderSpecificArrayOutput() DNSEndpointSpecEndpointsProviderSpecificArrayOutput
	ToDNSEndpointSpecEndpointsProviderSpecificArrayOutputWithContext(context.Context) DNSEndpointSpecEndpointsProviderSpecificArrayOutput
}

type DNSEndpointSpecEndpointsProviderSpecificArray []DNSEndpointSpecEndpointsProviderSpecificInput

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

func (i DNSEndpointSpecEndpointsProviderSpecificArray) ToDNSEndpointSpecEndpointsProviderSpecificArrayOutput() DNSEndpointSpecEndpointsProviderSpecificArrayOutput {
	return i.ToDNSEndpointSpecEndpointsProviderSpecificArrayOutputWithContext(context.Background())
}

func (i DNSEndpointSpecEndpointsProviderSpecificArray) ToDNSEndpointSpecEndpointsProviderSpecificArrayOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsProviderSpecificArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointSpecEndpointsProviderSpecificArrayOutput)
}

func (i DNSEndpointSpecEndpointsProviderSpecificArray) ToOutput(ctx context.Context) pulumix.Output[[]DNSEndpointSpecEndpointsProviderSpecific] {
	return pulumix.Output[[]DNSEndpointSpecEndpointsProviderSpecific]{
		OutputState: i.ToDNSEndpointSpecEndpointsProviderSpecificArrayOutputWithContext(ctx).OutputState,
	}
}

// ProviderSpecificProperty holds the name and value of a configuration which is specific to individual DNS providers
type DNSEndpointSpecEndpointsProviderSpecificOutput struct{ *pulumi.OutputState }

func (DNSEndpointSpecEndpointsProviderSpecificOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointSpecEndpointsProviderSpecific)(nil)).Elem()
}

func (o DNSEndpointSpecEndpointsProviderSpecificOutput) ToDNSEndpointSpecEndpointsProviderSpecificOutput() DNSEndpointSpecEndpointsProviderSpecificOutput {
	return o
}

func (o DNSEndpointSpecEndpointsProviderSpecificOutput) ToDNSEndpointSpecEndpointsProviderSpecificOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsProviderSpecificOutput {
	return o
}

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

func (o DNSEndpointSpecEndpointsProviderSpecificOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpointsProviderSpecific) *string { return v.Name }).(pulumi.StringPtrOutput)
}

func (o DNSEndpointSpecEndpointsProviderSpecificOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DNSEndpointSpecEndpointsProviderSpecific) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type DNSEndpointSpecEndpointsProviderSpecificArrayOutput struct{ *pulumi.OutputState }

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

func (o DNSEndpointSpecEndpointsProviderSpecificArrayOutput) ToDNSEndpointSpecEndpointsProviderSpecificArrayOutput() DNSEndpointSpecEndpointsProviderSpecificArrayOutput {
	return o
}

func (o DNSEndpointSpecEndpointsProviderSpecificArrayOutput) ToDNSEndpointSpecEndpointsProviderSpecificArrayOutputWithContext(ctx context.Context) DNSEndpointSpecEndpointsProviderSpecificArrayOutput {
	return o
}

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

func (o DNSEndpointSpecEndpointsProviderSpecificArrayOutput) Index(i pulumi.IntInput) DNSEndpointSpecEndpointsProviderSpecificOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DNSEndpointSpecEndpointsProviderSpecific {
		return vs[0].([]DNSEndpointSpecEndpointsProviderSpecific)[vs[1].(int)]
	}).(DNSEndpointSpecEndpointsProviderSpecificOutput)
}

// DNSEndpointStatus defines the observed state of DNSEndpoint
type DNSEndpointStatus struct {
	// The generation observed by the external-dns controller.
	ObservedGeneration *int `pulumi:"observedGeneration"`
}

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

	ToDNSEndpointStatusOutput() DNSEndpointStatusOutput
	ToDNSEndpointStatusOutputWithContext(context.Context) DNSEndpointStatusOutput
}

// DNSEndpointStatus defines the observed state of DNSEndpoint
type DNSEndpointStatusArgs struct {
	// The generation observed by the external-dns controller.
	ObservedGeneration pulumi.IntPtrInput `pulumi:"observedGeneration"`
}

func (DNSEndpointStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointStatus)(nil)).Elem()
}

func (i DNSEndpointStatusArgs) ToDNSEndpointStatusOutput() DNSEndpointStatusOutput {
	return i.ToDNSEndpointStatusOutputWithContext(context.Background())
}

func (i DNSEndpointStatusArgs) ToDNSEndpointStatusOutputWithContext(ctx context.Context) DNSEndpointStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointStatusOutput)
}

func (i DNSEndpointStatusArgs) ToOutput(ctx context.Context) pulumix.Output[DNSEndpointStatus] {
	return pulumix.Output[DNSEndpointStatus]{
		OutputState: i.ToDNSEndpointStatusOutputWithContext(ctx).OutputState,
	}
}

func (i DNSEndpointStatusArgs) ToDNSEndpointStatusPtrOutput() DNSEndpointStatusPtrOutput {
	return i.ToDNSEndpointStatusPtrOutputWithContext(context.Background())
}

func (i DNSEndpointStatusArgs) ToDNSEndpointStatusPtrOutputWithContext(ctx context.Context) DNSEndpointStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointStatusOutput).ToDNSEndpointStatusPtrOutputWithContext(ctx)
}

// DNSEndpointStatusPtrInput is an input type that accepts DNSEndpointStatusArgs, DNSEndpointStatusPtr and DNSEndpointStatusPtrOutput values.
// You can construct a concrete instance of `DNSEndpointStatusPtrInput` via:
//
//	        DNSEndpointStatusArgs{...}
//
//	or:
//
//	        nil
type DNSEndpointStatusPtrInput interface {
	pulumi.Input

	ToDNSEndpointStatusPtrOutput() DNSEndpointStatusPtrOutput
	ToDNSEndpointStatusPtrOutputWithContext(context.Context) DNSEndpointStatusPtrOutput
}

type dnsendpointStatusPtrType DNSEndpointStatusArgs

func DNSEndpointStatusPtr(v *DNSEndpointStatusArgs) DNSEndpointStatusPtrInput {
	return (*dnsendpointStatusPtrType)(v)
}

func (*dnsendpointStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DNSEndpointStatus)(nil)).Elem()
}

func (i *dnsendpointStatusPtrType) ToDNSEndpointStatusPtrOutput() DNSEndpointStatusPtrOutput {
	return i.ToDNSEndpointStatusPtrOutputWithContext(context.Background())
}

func (i *dnsendpointStatusPtrType) ToDNSEndpointStatusPtrOutputWithContext(ctx context.Context) DNSEndpointStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DNSEndpointStatusPtrOutput)
}

func (i *dnsendpointStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*DNSEndpointStatus] {
	return pulumix.Output[*DNSEndpointStatus]{
		OutputState: i.ToDNSEndpointStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// DNSEndpointStatus defines the observed state of DNSEndpoint
type DNSEndpointStatusOutput struct{ *pulumi.OutputState }

func (DNSEndpointStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DNSEndpointStatus)(nil)).Elem()
}

func (o DNSEndpointStatusOutput) ToDNSEndpointStatusOutput() DNSEndpointStatusOutput {
	return o
}

func (o DNSEndpointStatusOutput) ToDNSEndpointStatusOutputWithContext(ctx context.Context) DNSEndpointStatusOutput {
	return o
}

func (o DNSEndpointStatusOutput) ToDNSEndpointStatusPtrOutput() DNSEndpointStatusPtrOutput {
	return o.ToDNSEndpointStatusPtrOutputWithContext(context.Background())
}

func (o DNSEndpointStatusOutput) ToDNSEndpointStatusPtrOutputWithContext(ctx context.Context) DNSEndpointStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DNSEndpointStatus) *DNSEndpointStatus {
		return &v
	}).(DNSEndpointStatusPtrOutput)
}

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

// The generation observed by the external-dns controller.
func (o DNSEndpointStatusOutput) ObservedGeneration() pulumi.IntPtrOutput {
	return o.ApplyT(func(v DNSEndpointStatus) *int { return v.ObservedGeneration }).(pulumi.IntPtrOutput)
}

type DNSEndpointStatusPtrOutput struct{ *pulumi.OutputState }

func (DNSEndpointStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DNSEndpointStatus)(nil)).Elem()
}

func (o DNSEndpointStatusPtrOutput) ToDNSEndpointStatusPtrOutput() DNSEndpointStatusPtrOutput {
	return o
}

func (o DNSEndpointStatusPtrOutput) ToDNSEndpointStatusPtrOutputWithContext(ctx context.Context) DNSEndpointStatusPtrOutput {
	return o
}

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

func (o DNSEndpointStatusPtrOutput) Elem() DNSEndpointStatusOutput {
	return o.ApplyT(func(v *DNSEndpointStatus) DNSEndpointStatus {
		if v != nil {
			return *v
		}
		var ret DNSEndpointStatus
		return ret
	}).(DNSEndpointStatusOutput)
}

// The generation observed by the external-dns controller.
func (o DNSEndpointStatusPtrOutput) ObservedGeneration() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *DNSEndpointStatus) *int {
		if v == nil {
			return nil
		}
		return v.ObservedGeneration
	}).(pulumi.IntPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecInput)(nil)).Elem(), DNSEndpointSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecPtrInput)(nil)).Elem(), DNSEndpointSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecEndpointsInput)(nil)).Elem(), DNSEndpointSpecEndpointsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecEndpointsArrayInput)(nil)).Elem(), DNSEndpointSpecEndpointsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecEndpointsProviderSpecificInput)(nil)).Elem(), DNSEndpointSpecEndpointsProviderSpecificArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointSpecEndpointsProviderSpecificArrayInput)(nil)).Elem(), DNSEndpointSpecEndpointsProviderSpecificArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointStatusInput)(nil)).Elem(), DNSEndpointStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DNSEndpointStatusPtrInput)(nil)).Elem(), DNSEndpointStatusArgs{})
	pulumi.RegisterOutputType(DNSEndpointSpecOutput{})
	pulumi.RegisterOutputType(DNSEndpointSpecPtrOutput{})
	pulumi.RegisterOutputType(DNSEndpointSpecEndpointsOutput{})
	pulumi.RegisterOutputType(DNSEndpointSpecEndpointsArrayOutput{})
	pulumi.RegisterOutputType(DNSEndpointSpecEndpointsProviderSpecificOutput{})
	pulumi.RegisterOutputType(DNSEndpointSpecEndpointsProviderSpecificArrayOutput{})
	pulumi.RegisterOutputType(DNSEndpointStatusOutput{})
	pulumi.RegisterOutputType(DNSEndpointStatusPtrOutput{})
}
