route53

package
v3.29.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 15, 2021 License: Apache-2.0 Imports: 7 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	RecordTypeA     = RecordType("A")
	RecordTypeAAAA  = RecordType("AAAA")
	RecordTypeCNAME = RecordType("CNAME")
	RecordTypeCAA   = RecordType("CAA")
	RecordTypeMX    = RecordType("MX")
	RecordTypeNAPTR = RecordType("NAPTR")
	RecordTypeNS    = RecordType("NS")
	RecordTypePTR   = RecordType("PTR")
	RecordTypeSOA   = RecordType("SOA")
	RecordTypeSPF   = RecordType("SPF")
	RecordTypeSRV   = RecordType("SRV")
	RecordTypeTXT   = RecordType("TXT")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type DelegationSet 

type DelegationSet struct {
	pulumi.CustomResourceState

	// A list of authoritative name servers for the hosted zone
	// (effectively a list of NS records).
	NameServers pulumi.StringArrayOutput `pulumi:"nameServers"`
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrOutput `pulumi:"referenceName"`
}

Provides a [Route53 Delegation Set](https://docs.aws.amazon.com/Route53/latest/APIReference/API-actions-by-function.html#actions-by-function-reusable-delegation-sets) resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := route53.NewDelegationSet(ctx, "main", &route53.DelegationSetArgs{
			ReferenceName: pulumi.String("DynDNS"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZone(ctx, "primary", &route53.ZoneArgs{
			DelegationSetId: main.ID(),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZone(ctx, "secondary", &route53.ZoneArgs{
			DelegationSetId: main.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Delegation Sets can be imported using the `delegation set id`, e.g.

```sh 

$ pulumi import aws:route53/delegationSet:DelegationSet set1 N1PA6795SAMPLE

```

func GetDelegationSet 

func GetDelegationSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DelegationSetState, opts ...pulumi.ResourceOption) (*DelegationSet, error)

GetDelegationSet gets an existing DelegationSet resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDelegationSet 

func NewDelegationSet(ctx *pulumi.Context,
	name string, args *DelegationSetArgs, opts ...pulumi.ResourceOption) (*DelegationSet, error)

NewDelegationSet registers a new resource with the given unique name, arguments, and options.

func (*DelegationSet) ElementType added in v3.13.0 

func (*DelegationSet) ElementType() reflect.Type

func (*DelegationSet) ToDelegationSetOutput added in v3.13.0 

func (i *DelegationSet) ToDelegationSetOutput() DelegationSetOutput

func (*DelegationSet) ToDelegationSetOutputWithContext added in v3.13.0 

func (i *DelegationSet) ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput

func (*DelegationSet) ToDelegationSetPtrOutput added in v3.25.0 

func (i *DelegationSet) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (*DelegationSet) ToDelegationSetPtrOutputWithContext added in v3.25.0 

func (i *DelegationSet) ToDelegationSetPtrOutputWithContext(ctx context.Context) DelegationSetPtrOutput

type DelegationSetArgs 

type DelegationSetArgs struct {
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrInput
}

The set of arguments for constructing a DelegationSet resource.

func (DelegationSetArgs) ElementType 

func (DelegationSetArgs) ElementType() reflect.Type

type DelegationSetArray added in v3.25.0 

type DelegationSetArray []DelegationSetInput

func (DelegationSetArray) ElementType added in v3.25.0 

func (DelegationSetArray) ElementType() reflect.Type

func (DelegationSetArray) ToDelegationSetArrayOutput added in v3.25.0 

func (i DelegationSetArray) ToDelegationSetArrayOutput() DelegationSetArrayOutput

func (DelegationSetArray) ToDelegationSetArrayOutputWithContext added in v3.25.0 

func (i DelegationSetArray) ToDelegationSetArrayOutputWithContext(ctx context.Context) DelegationSetArrayOutput

type DelegationSetArrayInput added in v3.25.0 

type DelegationSetArrayInput interface {
	pulumi.Input

	ToDelegationSetArrayOutput() DelegationSetArrayOutput
	ToDelegationSetArrayOutputWithContext(context.Context) DelegationSetArrayOutput
}

DelegationSetArrayInput is an input type that accepts DelegationSetArray and DelegationSetArrayOutput values. You can construct a concrete instance of `DelegationSetArrayInput` via: 

DelegationSetArray{ DelegationSetArgs{...} }

type DelegationSetArrayOutput added in v3.25.0 

type DelegationSetArrayOutput struct{ *pulumi.OutputState }

func (DelegationSetArrayOutput) ElementType added in v3.25.0 

func (DelegationSetArrayOutput) ElementType() reflect.Type

func (DelegationSetArrayOutput) Index added in v3.25.0 

func (o DelegationSetArrayOutput) Index(i pulumi.IntInput) DelegationSetOutput

func (DelegationSetArrayOutput) ToDelegationSetArrayOutput added in v3.25.0 

func (o DelegationSetArrayOutput) ToDelegationSetArrayOutput() DelegationSetArrayOutput

func (DelegationSetArrayOutput) ToDelegationSetArrayOutputWithContext added in v3.25.0 

func (o DelegationSetArrayOutput) ToDelegationSetArrayOutputWithContext(ctx context.Context) DelegationSetArrayOutput

type DelegationSetInput added in v3.13.0 

type DelegationSetInput interface {
	pulumi.Input

	ToDelegationSetOutput() DelegationSetOutput
	ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput
}

type DelegationSetMap added in v3.25.0 

type DelegationSetMap map[string]DelegationSetInput

func (DelegationSetMap) ElementType added in v3.25.0 

func (DelegationSetMap) ElementType() reflect.Type

func (DelegationSetMap) ToDelegationSetMapOutput added in v3.25.0 

func (i DelegationSetMap) ToDelegationSetMapOutput() DelegationSetMapOutput

func (DelegationSetMap) ToDelegationSetMapOutputWithContext added in v3.25.0 

func (i DelegationSetMap) ToDelegationSetMapOutputWithContext(ctx context.Context) DelegationSetMapOutput

type DelegationSetMapInput added in v3.25.0 

type DelegationSetMapInput interface {
	pulumi.Input

	ToDelegationSetMapOutput() DelegationSetMapOutput
	ToDelegationSetMapOutputWithContext(context.Context) DelegationSetMapOutput
}

DelegationSetMapInput is an input type that accepts DelegationSetMap and DelegationSetMapOutput values. You can construct a concrete instance of `DelegationSetMapInput` via: 

DelegationSetMap{ "key": DelegationSetArgs{...} }

type DelegationSetMapOutput added in v3.25.0 

type DelegationSetMapOutput struct{ *pulumi.OutputState }

func (DelegationSetMapOutput) ElementType added in v3.25.0 

func (DelegationSetMapOutput) ElementType() reflect.Type

func (DelegationSetMapOutput) MapIndex added in v3.25.0 

func (o DelegationSetMapOutput) MapIndex(k pulumi.StringInput) DelegationSetOutput

func (DelegationSetMapOutput) ToDelegationSetMapOutput added in v3.25.0 

func (o DelegationSetMapOutput) ToDelegationSetMapOutput() DelegationSetMapOutput

func (DelegationSetMapOutput) ToDelegationSetMapOutputWithContext added in v3.25.0 

func (o DelegationSetMapOutput) ToDelegationSetMapOutputWithContext(ctx context.Context) DelegationSetMapOutput

type DelegationSetOutput added in v3.13.0 

type DelegationSetOutput struct {
	*pulumi.OutputState
}

func (DelegationSetOutput) ElementType added in v3.13.0 

func (DelegationSetOutput) ElementType() reflect.Type

func (DelegationSetOutput) ToDelegationSetOutput added in v3.13.0 

func (o DelegationSetOutput) ToDelegationSetOutput() DelegationSetOutput

func (DelegationSetOutput) ToDelegationSetOutputWithContext added in v3.13.0 

func (o DelegationSetOutput) ToDelegationSetOutputWithContext(ctx context.Context) DelegationSetOutput

func (DelegationSetOutput) ToDelegationSetPtrOutput added in v3.25.0 

func (o DelegationSetOutput) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (DelegationSetOutput) ToDelegationSetPtrOutputWithContext added in v3.25.0 

func (o DelegationSetOutput) ToDelegationSetPtrOutputWithContext(ctx context.Context) DelegationSetPtrOutput

type DelegationSetPtrInput added in v3.25.0 

type DelegationSetPtrInput interface {
	pulumi.Input

	ToDelegationSetPtrOutput() DelegationSetPtrOutput
	ToDelegationSetPtrOutputWithContext(ctx context.Context) DelegationSetPtrOutput
}

type DelegationSetPtrOutput added in v3.25.0 

type DelegationSetPtrOutput struct {
	*pulumi.OutputState
}

func (DelegationSetPtrOutput) ElementType added in v3.25.0 

func (DelegationSetPtrOutput) ElementType() reflect.Type

func (DelegationSetPtrOutput) ToDelegationSetPtrOutput added in v3.25.0 

func (o DelegationSetPtrOutput) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (DelegationSetPtrOutput) ToDelegationSetPtrOutputWithContext added in v3.25.0 

func (o DelegationSetPtrOutput) ToDelegationSetPtrOutputWithContext(ctx context.Context) DelegationSetPtrOutput

type DelegationSetState 

type DelegationSetState struct {
	// A list of authoritative name servers for the hosted zone
	// (effectively a list of NS records).
	NameServers pulumi.StringArrayInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single delegation set amongst others)
	ReferenceName pulumi.StringPtrInput
}

func (DelegationSetState) ElementType 

func (DelegationSetState) ElementType() reflect.Type

type GetResolverEndpointFilter added in v3.12.0 

type GetResolverEndpointFilter struct {
	Name   string   `pulumi:"name"`
	Values []string `pulumi:"values"`
}

type GetResolverEndpointFilterArgs added in v3.12.0 

type GetResolverEndpointFilterArgs struct {
	Name   pulumi.StringInput      `pulumi:"name"`
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetResolverEndpointFilterArgs) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArgs) ElementType() reflect.Type

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput added in v3.12.0 

func (i GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutputWithContext added in v3.12.0 

func (i GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutputWithContext(ctx context.Context) GetResolverEndpointFilterOutput

type GetResolverEndpointFilterArray added in v3.12.0 

type GetResolverEndpointFilterArray []GetResolverEndpointFilterInput

func (GetResolverEndpointFilterArray) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArray) ElementType() reflect.Type

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput added in v3.12.0 

func (i GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutputWithContext added in v3.12.0 

func (i GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutputWithContext(ctx context.Context) GetResolverEndpointFilterArrayOutput

type GetResolverEndpointFilterArrayInput added in v3.12.0 

type GetResolverEndpointFilterArrayInput interface {
	pulumi.Input

	ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput
	ToGetResolverEndpointFilterArrayOutputWithContext(context.Context) GetResolverEndpointFilterArrayOutput
}

GetResolverEndpointFilterArrayInput is an input type that accepts GetResolverEndpointFilterArray and GetResolverEndpointFilterArrayOutput values. You can construct a concrete instance of `GetResolverEndpointFilterArrayInput` via: 

GetResolverEndpointFilterArray{ GetResolverEndpointFilterArgs{...} }

type GetResolverEndpointFilterArrayOutput added in v3.12.0 

type GetResolverEndpointFilterArrayOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterArrayOutput) ElementType added in v3.12.0 

func (GetResolverEndpointFilterArrayOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterArrayOutput) Index added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) Index(i pulumi.IntInput) GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutputWithContext added in v3.12.0 

func (o GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutputWithContext(ctx context.Context) GetResolverEndpointFilterArrayOutput

type GetResolverEndpointFilterInput added in v3.12.0 

type GetResolverEndpointFilterInput interface {
	pulumi.Input

	ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput
	ToGetResolverEndpointFilterOutputWithContext(context.Context) GetResolverEndpointFilterOutput
}

GetResolverEndpointFilterInput is an input type that accepts GetResolverEndpointFilterArgs and GetResolverEndpointFilterOutput values. You can construct a concrete instance of `GetResolverEndpointFilterInput` via: 

GetResolverEndpointFilterArgs{...}

type GetResolverEndpointFilterOutput added in v3.12.0 

type GetResolverEndpointFilterOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterOutput) ElementType added in v3.12.0 

func (GetResolverEndpointFilterOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterOutput) Name added in v3.12.0 

func (o GetResolverEndpointFilterOutput) Name() pulumi.StringOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput added in v3.12.0 

func (o GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutputWithContext added in v3.12.0 

func (o GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutputWithContext(ctx context.Context) GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterOutput) Values added in v3.12.0 

func (o GetResolverEndpointFilterOutput) Values() pulumi.StringArrayOutput

type GetResolverRulesArgs 

type GetResolverRulesArgs struct {
	// When the desired resolver rules are shared with another AWS account, the account ID of the account that the rules are shared with.
	OwnerId *string `pulumi:"ownerId"`
	// The ID of the outbound resolver endpoint for the desired resolver rules.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The rule type of the desired resolver rules. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType *string `pulumi:"ruleType"`
	// Whether the desired resolver rules are shared and, if so, whether the current account is sharing the rules with another account, or another account is sharing the rules with the current account. Valid values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus *string `pulumi:"shareStatus"`
}

A collection of arguments for invoking getResolverRules.

type GetResolverRulesResult 

type GetResolverRulesResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id                 string  `pulumi:"id"`
	OwnerId            *string `pulumi:"ownerId"`
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The IDs of the matched resolver rules.
	ResolverRuleIds []string `pulumi:"resolverRuleIds"`
	RuleType        *string  `pulumi:"ruleType"`
	ShareStatus     *string  `pulumi:"shareStatus"`
}

A collection of values returned by getResolverRules.

func GetResolverRules 

func GetResolverRules(ctx *pulumi.Context, args *GetResolverRulesArgs, opts ...pulumi.InvokeOption) (*GetResolverRulesResult, error)

`route53.getResolverRules` provides details about a set of Route53 Resolver rules.

## Example Usage

Retrieving the default resolver rule.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "Route 53 Resolver"
		opt1 := "RECURSIVE"
		opt2 := "NOT_SHARED"
		_, err := route53.GetResolverRules(ctx, &route53.GetResolverRulesArgs{
			OwnerId:     &opt0,
			RuleType:    &opt1,
			ShareStatus: &opt2,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "FORWARD"
		opt1 := "SHARED_WITH_ME"
		_, err := route53.GetResolverRules(ctx, &route53.GetResolverRulesArgs{
			RuleType:    &opt0,
			ShareStatus: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type HealthCheck 

type HealthCheck struct {
	pulumi.CustomResourceState

	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrOutput `pulumi:"childHealthThreshold"`
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayOutput `pulumi:"childHealthchecks"`
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrOutput `pulumi:"cloudwatchAlarmName"`
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrOutput `pulumi:"cloudwatchAlarmRegion"`
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrOutput `pulumi:"disabled"`
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolOutput `pulumi:"enableSni"`
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrOutput `pulumi:"failureThreshold"`
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrOutput `pulumi:"fqdn"`
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrOutput `pulumi:"insufficientDataHealthStatus"`
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrOutput `pulumi:"invertHealthcheck"`
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrOutput `pulumi:"ipAddress"`
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrOutput `pulumi:"measureLatency"`
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrOutput `pulumi:"port"`
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrOutput `pulumi:"referenceName"`
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayOutput `pulumi:"regions"`
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrOutput `pulumi:"requestInterval"`
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrOutput `pulumi:"resourcePath"`
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrOutput `pulumi:"searchString"`
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringOutput `pulumi:"type"`
}

Provides a Route53 health check.

## Example Usage ### Connectivity and HTTP Status Code Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			FailureThreshold: pulumi.Int(5),
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(80),
			RequestInterval:  pulumi.Int(30),
			ResourcePath:     pulumi.String("/"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-test-health-check"),
			},
			Type: pulumi.String("HTTP"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Connectivity and String Matching Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			FailureThreshold: pulumi.Int(5),
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(443),
			RequestInterval:  pulumi.Int(30),
			ResourcePath:     pulumi.String("/"),
			SearchString:     pulumi.String("example"),
			Type:             pulumi.String("HTTPS_STR_MATCH"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### CloudWatch Alarm Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := cloudwatch.NewMetricAlarm(ctx, "foobar", &cloudwatch.MetricAlarmArgs{
			ComparisonOperator: pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:  pulumi.Int(2),
			MetricName:         pulumi.String("CPUUtilization"),
			Namespace:          pulumi.String("AWS/EC2"),
			Period:             pulumi.Int(120),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Float64(80),
			AlarmDescription:   pulumi.String("This metric monitors ec2 cpu utilization"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewHealthCheck(ctx, "foo", &route53.HealthCheckArgs{
			Type:                         pulumi.String("CLOUDWATCH_METRIC"),
			CloudwatchAlarmName:          foobar.Name,
			CloudwatchAlarmRegion:        pulumi.String("us-west-2"),
			InsufficientDataHealthStatus: pulumi.String("Healthy"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Health Checks can be imported using the `health check id`, e.g.

```sh 

$ pulumi import aws:route53/healthCheck:HealthCheck http_check abcdef11-2222-3333-4444-555555fedcba

```

func GetHealthCheck 

func GetHealthCheck(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HealthCheckState, opts ...pulumi.ResourceOption) (*HealthCheck, error)

GetHealthCheck gets an existing HealthCheck resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewHealthCheck 

func NewHealthCheck(ctx *pulumi.Context,
	name string, args *HealthCheckArgs, opts ...pulumi.ResourceOption) (*HealthCheck, error)

NewHealthCheck registers a new resource with the given unique name, arguments, and options.

func (*HealthCheck) ElementType added in v3.13.0 

func (*HealthCheck) ElementType() reflect.Type

func (*HealthCheck) ToHealthCheckOutput added in v3.13.0 

func (i *HealthCheck) ToHealthCheckOutput() HealthCheckOutput

func (*HealthCheck) ToHealthCheckOutputWithContext added in v3.13.0 

func (i *HealthCheck) ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput

func (*HealthCheck) ToHealthCheckPtrOutput added in v3.25.0 

func (i *HealthCheck) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (*HealthCheck) ToHealthCheckPtrOutputWithContext added in v3.25.0 

func (i *HealthCheck) ToHealthCheckPtrOutputWithContext(ctx context.Context) HealthCheckPtrOutput

type HealthCheckArgs 

type HealthCheckArgs struct {
	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrInput
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayInput
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrInput
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrInput
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrInput
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolPtrInput
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrInput
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrInput
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrInput
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrInput
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrInput
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrInput
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrInput
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayInput
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrInput
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrInput
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrInput
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapInput
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringInput
}

The set of arguments for constructing a HealthCheck resource.

func (HealthCheckArgs) ElementType 

func (HealthCheckArgs) ElementType() reflect.Type

type HealthCheckArray added in v3.25.0 

type HealthCheckArray []HealthCheckInput

func (HealthCheckArray) ElementType added in v3.25.0 

func (HealthCheckArray) ElementType() reflect.Type

func (HealthCheckArray) ToHealthCheckArrayOutput added in v3.25.0 

func (i HealthCheckArray) ToHealthCheckArrayOutput() HealthCheckArrayOutput

func (HealthCheckArray) ToHealthCheckArrayOutputWithContext added in v3.25.0 

func (i HealthCheckArray) ToHealthCheckArrayOutputWithContext(ctx context.Context) HealthCheckArrayOutput

type HealthCheckArrayInput added in v3.25.0 

type HealthCheckArrayInput interface {
	pulumi.Input

	ToHealthCheckArrayOutput() HealthCheckArrayOutput
	ToHealthCheckArrayOutputWithContext(context.Context) HealthCheckArrayOutput
}

HealthCheckArrayInput is an input type that accepts HealthCheckArray and HealthCheckArrayOutput values. You can construct a concrete instance of `HealthCheckArrayInput` via: 

HealthCheckArray{ HealthCheckArgs{...} }

type HealthCheckArrayOutput added in v3.25.0 

type HealthCheckArrayOutput struct{ *pulumi.OutputState }

func (HealthCheckArrayOutput) ElementType added in v3.25.0 

func (HealthCheckArrayOutput) ElementType() reflect.Type

func (HealthCheckArrayOutput) Index added in v3.25.0 

func (o HealthCheckArrayOutput) Index(i pulumi.IntInput) HealthCheckOutput

func (HealthCheckArrayOutput) ToHealthCheckArrayOutput added in v3.25.0 

func (o HealthCheckArrayOutput) ToHealthCheckArrayOutput() HealthCheckArrayOutput

func (HealthCheckArrayOutput) ToHealthCheckArrayOutputWithContext added in v3.25.0 

func (o HealthCheckArrayOutput) ToHealthCheckArrayOutputWithContext(ctx context.Context) HealthCheckArrayOutput

type HealthCheckInput added in v3.13.0 

type HealthCheckInput interface {
	pulumi.Input

	ToHealthCheckOutput() HealthCheckOutput
	ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput
}

type HealthCheckMap added in v3.25.0 

type HealthCheckMap map[string]HealthCheckInput

func (HealthCheckMap) ElementType added in v3.25.0 

func (HealthCheckMap) ElementType() reflect.Type

func (HealthCheckMap) ToHealthCheckMapOutput added in v3.25.0 

func (i HealthCheckMap) ToHealthCheckMapOutput() HealthCheckMapOutput

func (HealthCheckMap) ToHealthCheckMapOutputWithContext added in v3.25.0 

func (i HealthCheckMap) ToHealthCheckMapOutputWithContext(ctx context.Context) HealthCheckMapOutput

type HealthCheckMapInput added in v3.25.0 

type HealthCheckMapInput interface {
	pulumi.Input

	ToHealthCheckMapOutput() HealthCheckMapOutput
	ToHealthCheckMapOutputWithContext(context.Context) HealthCheckMapOutput
}

HealthCheckMapInput is an input type that accepts HealthCheckMap and HealthCheckMapOutput values. You can construct a concrete instance of `HealthCheckMapInput` via: 

HealthCheckMap{ "key": HealthCheckArgs{...} }

type HealthCheckMapOutput added in v3.25.0 

type HealthCheckMapOutput struct{ *pulumi.OutputState }

func (HealthCheckMapOutput) ElementType added in v3.25.0 

func (HealthCheckMapOutput) ElementType() reflect.Type

func (HealthCheckMapOutput) MapIndex added in v3.25.0 

func (o HealthCheckMapOutput) MapIndex(k pulumi.StringInput) HealthCheckOutput

func (HealthCheckMapOutput) ToHealthCheckMapOutput added in v3.25.0 

func (o HealthCheckMapOutput) ToHealthCheckMapOutput() HealthCheckMapOutput

func (HealthCheckMapOutput) ToHealthCheckMapOutputWithContext added in v3.25.0 

func (o HealthCheckMapOutput) ToHealthCheckMapOutputWithContext(ctx context.Context) HealthCheckMapOutput

type HealthCheckOutput added in v3.13.0 

type HealthCheckOutput struct {
	*pulumi.OutputState
}

func (HealthCheckOutput) ElementType added in v3.13.0 

func (HealthCheckOutput) ElementType() reflect.Type

func (HealthCheckOutput) ToHealthCheckOutput added in v3.13.0 

func (o HealthCheckOutput) ToHealthCheckOutput() HealthCheckOutput

func (HealthCheckOutput) ToHealthCheckOutputWithContext added in v3.13.0 

func (o HealthCheckOutput) ToHealthCheckOutputWithContext(ctx context.Context) HealthCheckOutput

func (HealthCheckOutput) ToHealthCheckPtrOutput added in v3.25.0 

func (o HealthCheckOutput) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (HealthCheckOutput) ToHealthCheckPtrOutputWithContext added in v3.25.0 

func (o HealthCheckOutput) ToHealthCheckPtrOutputWithContext(ctx context.Context) HealthCheckPtrOutput

type HealthCheckPtrInput added in v3.25.0 

type HealthCheckPtrInput interface {
	pulumi.Input

	ToHealthCheckPtrOutput() HealthCheckPtrOutput
	ToHealthCheckPtrOutputWithContext(ctx context.Context) HealthCheckPtrOutput
}

type HealthCheckPtrOutput added in v3.25.0 

type HealthCheckPtrOutput struct {
	*pulumi.OutputState
}

func (HealthCheckPtrOutput) ElementType added in v3.25.0 

func (HealthCheckPtrOutput) ElementType() reflect.Type

func (HealthCheckPtrOutput) ToHealthCheckPtrOutput added in v3.25.0 

func (o HealthCheckPtrOutput) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (HealthCheckPtrOutput) ToHealthCheckPtrOutputWithContext added in v3.25.0 

func (o HealthCheckPtrOutput) ToHealthCheckPtrOutputWithContext(ctx context.Context) HealthCheckPtrOutput

type HealthCheckState 

type HealthCheckState struct {
	// The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
	ChildHealthThreshold pulumi.IntPtrInput
	// For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
	ChildHealthchecks pulumi.StringArrayInput
	// The name of the CloudWatch alarm.
	CloudwatchAlarmName pulumi.StringPtrInput
	// The CloudWatchRegion that the CloudWatch alarm was created in.
	CloudwatchAlarmRegion pulumi.StringPtrInput
	// A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
	// * For health checks that check the health of endpoints, Route5 53 stops submitting requests to your application, server, or other resource.
	// * For calculated health checks, Route 53 stops aggregating the status of the referenced health checks.
	// * For health checks that monitor CloudWatch alarms, Route 53 stops monitoring the corresponding CloudWatch metrics.
	Disabled pulumi.BoolPtrInput
	// A boolean value that indicates whether Route53 should send the `fqdn` to the endpoint when performing the health check. This defaults to AWS' defaults: when the `type` is "HTTPS" `enableSni` defaults to `true`, when `type` is anything else `enableSni` defaults to `false`.
	EnableSni pulumi.BoolPtrInput
	// The number of consecutive health checks that an endpoint must pass or fail.
	FailureThreshold pulumi.IntPtrInput
	// The fully qualified domain name of the endpoint to be checked.
	Fqdn pulumi.StringPtrInput
	// The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are `Healthy` , `Unhealthy` and `LastKnownStatus`.
	InsufficientDataHealthStatus pulumi.StringPtrInput
	// A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
	InvertHealthcheck pulumi.BoolPtrInput
	// The IP address of the endpoint to be checked.
	IpAddress pulumi.StringPtrInput
	// A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
	MeasureLatency pulumi.BoolPtrInput
	// The port of the endpoint to be checked.
	Port pulumi.IntPtrInput
	// This is a reference name used in Caller Reference
	// (helpful for identifying single healthCheck set amongst others)
	ReferenceName pulumi.StringPtrInput
	// A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.
	Regions pulumi.StringArrayInput
	// The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
	RequestInterval pulumi.IntPtrInput
	// The path that you want Amazon Route 53 to request when performing health checks.
	ResourcePath pulumi.StringPtrInput
	// String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with `HTTP_STR_MATCH` and `HTTPS_STR_MATCH`.
	SearchString pulumi.StringPtrInput
	// A map of tags to assign to the health check.
	Tags pulumi.StringMapInput
	// The protocol to use when performing health checks. Valid values are `HTTP`, `HTTPS`, `HTTP_STR_MATCH`, `HTTPS_STR_MATCH`, `TCP`, `CALCULATED` and `CLOUDWATCH_METRIC`.
	Type pulumi.StringPtrInput
}

func (HealthCheckState) ElementType 

func (HealthCheckState) ElementType() reflect.Type

type KeySigningKey added in v3.28.0 

type KeySigningKey struct {
	pulumi.CustomResourceState

	// A string used to represent the delegation signer digest algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.3](https://tools.ietf.org/html/rfc8624#section-3.3).
	DigestAlgorithmMnemonic pulumi.StringOutput `pulumi:"digestAlgorithmMnemonic"`
	// An integer used to represent the delegation signer digest algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.3](https://tools.ietf.org/html/rfc8624#section-3.3).
	DigestAlgorithmType pulumi.IntOutput `pulumi:"digestAlgorithmType"`
	// A cryptographic digest of a DNSKEY resource record (RR). DNSKEY records are used to publish the public key that resolvers can use to verify DNSSEC signatures that are used to secure certain kinds of information provided by the DNS system.
	DigestValue pulumi.StringOutput `pulumi:"digestValue"`
	// A string that represents a DNSKEY record.
	DnskeyRecord pulumi.StringOutput `pulumi:"dnskeyRecord"`
	// A string that represents a delegation signer (DS) record.
	DsRecord pulumi.StringOutput `pulumi:"dsRecord"`
	// An integer that specifies how the key is used. For key-signing key (KSK), this value is always 257.
	Flag pulumi.IntOutput `pulumi:"flag"`
	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringOutput `pulumi:"hostedZoneId"`
	// Amazon Resource Name (ARN) of the Key Management Service (KMS) Key. This must be unique for each key-signing key (KSK) in a single hosted zone. This key must be in the `us-east-1` Region and meet certain requirements, which are described in the [Route 53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-configuring-dnssec-cmk-requirements.html) and [Route 53 API Reference](https://docs.aws.amazon.com/Route53/latest/APIReference/API_CreateKeySigningKey.html).
	KeyManagementServiceArn pulumi.StringOutput `pulumi:"keyManagementServiceArn"`
	// An integer used to identify the DNSSEC record for the domain name. The process used to calculate the value is described in [RFC-4034 Appendix B](https://tools.ietf.org/rfc/rfc4034.txt).
	KeyTag pulumi.IntOutput `pulumi:"keyTag"`
	// Name of the key-signing key (KSK). Must be unique for each key-singing key in the same hosted zone.
	Name pulumi.StringOutput `pulumi:"name"`
	// The public key, represented as a Base64 encoding, as required by [RFC-4034 Page 5](https://tools.ietf.org/rfc/rfc4034.txt).
	PublicKey pulumi.StringOutput `pulumi:"publicKey"`
	// A string used to represent the signing algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.1](https://tools.ietf.org/html/rfc8624#section-3.1).
	SigningAlgorithmMnemonic pulumi.StringOutput `pulumi:"signingAlgorithmMnemonic"`
	// An integer used to represent the signing algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.1](https://tools.ietf.org/html/rfc8624#section-3.1).
	SigningAlgorithmType pulumi.IntOutput `pulumi:"signingAlgorithmType"`
	// Status of the key-signing key (KSK). Valid values: `ACTIVE`, `INACTIVE`. Defaults to `ACTIVE`.
	Status pulumi.StringPtrOutput `pulumi:"status"`
}

Manages an Route 53 Key Signing Key. For more information about managing Domain Name System Security Extensions (DNSSEC)in Route 53, see the [Route 53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-configuring-dnssec.html).

## Example Usage

```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Statement": []interface{}{
				map[string]interface{}{
					"Action": []string{
						"kms:DescribeKey",
						"kms:GetPublicKey",
						"kms:Sign",
					},
					"Effect": "Allow",
					"Principal": map[string]interface{}{
						"Service": "api-service.dnssec.route53.aws.internal",
					},
					"Sid": "Route 53 DNSSEC Permissions",
				},
				map[string]interface{}{
					"Action": "kms:*",
					"Effect": "Allow",
					"Principal": map[string]interface{}{
						"AWS": "*",
					},
					"Resource": "*",
					"Sid":      "IAM User Permissions",
				},
			},
			"Version": "2012-10-17",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			CustomerMasterKeySpec: pulumi.String("ECC_NIST_P256"),
			DeletionWindowInDays:  pulumi.Int(7),
			KeyUsage:              pulumi.String("SIGN_VERIFY"),
			Policy:                pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZone(ctx, "exampleZone", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewKeySigningKey(ctx, "exampleKeySigningKey", &route53.KeySigningKeyArgs{
			HostedZoneId:            pulumi.Any(aws_route53_zone.Test.Id),
			KeyManagementServiceArn: pulumi.Any(aws_kms_key.Test.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

`aws_route53_key_signing_key` resources can be imported by using the Route 53 Hosted Zone identifier and KMS Key identifier, separated by a comma (`,`), e.g.

```sh 

$ pulumi import aws:route53/keySigningKey:KeySigningKey example Z1D633PJN98FT9,example

```

func GetKeySigningKey added in v3.28.0 

func GetKeySigningKey(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *KeySigningKeyState, opts ...pulumi.ResourceOption) (*KeySigningKey, error)

GetKeySigningKey gets an existing KeySigningKey resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewKeySigningKey added in v3.28.0 

func NewKeySigningKey(ctx *pulumi.Context,
	name string, args *KeySigningKeyArgs, opts ...pulumi.ResourceOption) (*KeySigningKey, error)

NewKeySigningKey registers a new resource with the given unique name, arguments, and options.

func (*KeySigningKey) ElementType added in v3.28.0 

func (*KeySigningKey) ElementType() reflect.Type

func (*KeySigningKey) ToKeySigningKeyOutput added in v3.28.0 

func (i *KeySigningKey) ToKeySigningKeyOutput() KeySigningKeyOutput

func (*KeySigningKey) ToKeySigningKeyOutputWithContext added in v3.28.0 

func (i *KeySigningKey) ToKeySigningKeyOutputWithContext(ctx context.Context) KeySigningKeyOutput

func (*KeySigningKey) ToKeySigningKeyPtrOutput added in v3.28.0 

func (i *KeySigningKey) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (*KeySigningKey) ToKeySigningKeyPtrOutputWithContext added in v3.28.0 

func (i *KeySigningKey) ToKeySigningKeyPtrOutputWithContext(ctx context.Context) KeySigningKeyPtrOutput

type KeySigningKeyArgs added in v3.28.0 

type KeySigningKeyArgs struct {
	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringInput
	// Amazon Resource Name (ARN) of the Key Management Service (KMS) Key. This must be unique for each key-signing key (KSK) in a single hosted zone. This key must be in the `us-east-1` Region and meet certain requirements, which are described in the [Route 53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-configuring-dnssec-cmk-requirements.html) and [Route 53 API Reference](https://docs.aws.amazon.com/Route53/latest/APIReference/API_CreateKeySigningKey.html).
	KeyManagementServiceArn pulumi.StringInput
	// Name of the key-signing key (KSK). Must be unique for each key-singing key in the same hosted zone.
	Name pulumi.StringPtrInput
	// Status of the key-signing key (KSK). Valid values: `ACTIVE`, `INACTIVE`. Defaults to `ACTIVE`.
	Status pulumi.StringPtrInput
}

The set of arguments for constructing a KeySigningKey resource.

func (KeySigningKeyArgs) ElementType added in v3.28.0 

func (KeySigningKeyArgs) ElementType() reflect.Type

type KeySigningKeyArray added in v3.28.0 

type KeySigningKeyArray []KeySigningKeyInput

func (KeySigningKeyArray) ElementType added in v3.28.0 

func (KeySigningKeyArray) ElementType() reflect.Type

func (KeySigningKeyArray) ToKeySigningKeyArrayOutput added in v3.28.0 

func (i KeySigningKeyArray) ToKeySigningKeyArrayOutput() KeySigningKeyArrayOutput

func (KeySigningKeyArray) ToKeySigningKeyArrayOutputWithContext added in v3.28.0 

func (i KeySigningKeyArray) ToKeySigningKeyArrayOutputWithContext(ctx context.Context) KeySigningKeyArrayOutput

type KeySigningKeyArrayInput added in v3.28.0 

type KeySigningKeyArrayInput interface {
	pulumi.Input

	ToKeySigningKeyArrayOutput() KeySigningKeyArrayOutput
	ToKeySigningKeyArrayOutputWithContext(context.Context) KeySigningKeyArrayOutput
}

KeySigningKeyArrayInput is an input type that accepts KeySigningKeyArray and KeySigningKeyArrayOutput values. You can construct a concrete instance of `KeySigningKeyArrayInput` via: 

KeySigningKeyArray{ KeySigningKeyArgs{...} }

type KeySigningKeyArrayOutput added in v3.28.0 

type KeySigningKeyArrayOutput struct{ *pulumi.OutputState }

func (KeySigningKeyArrayOutput) ElementType added in v3.28.0 

func (KeySigningKeyArrayOutput) ElementType() reflect.Type

func (KeySigningKeyArrayOutput) Index added in v3.28.0 

func (o KeySigningKeyArrayOutput) Index(i pulumi.IntInput) KeySigningKeyOutput

func (KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutput added in v3.28.0 

func (o KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutput() KeySigningKeyArrayOutput

func (KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutputWithContext added in v3.28.0 

func (o KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutputWithContext(ctx context.Context) KeySigningKeyArrayOutput

type KeySigningKeyInput added in v3.28.0 

type KeySigningKeyInput interface {
	pulumi.Input

	ToKeySigningKeyOutput() KeySigningKeyOutput
	ToKeySigningKeyOutputWithContext(ctx context.Context) KeySigningKeyOutput
}

type KeySigningKeyMap added in v3.28.0 

type KeySigningKeyMap map[string]KeySigningKeyInput

func (KeySigningKeyMap) ElementType added in v3.28.0 

func (KeySigningKeyMap) ElementType() reflect.Type

func (KeySigningKeyMap) ToKeySigningKeyMapOutput added in v3.28.0 

func (i KeySigningKeyMap) ToKeySigningKeyMapOutput() KeySigningKeyMapOutput

func (KeySigningKeyMap) ToKeySigningKeyMapOutputWithContext added in v3.28.0 

func (i KeySigningKeyMap) ToKeySigningKeyMapOutputWithContext(ctx context.Context) KeySigningKeyMapOutput

type KeySigningKeyMapInput added in v3.28.0 

type KeySigningKeyMapInput interface {
	pulumi.Input

	ToKeySigningKeyMapOutput() KeySigningKeyMapOutput
	ToKeySigningKeyMapOutputWithContext(context.Context) KeySigningKeyMapOutput
}

KeySigningKeyMapInput is an input type that accepts KeySigningKeyMap and KeySigningKeyMapOutput values. You can construct a concrete instance of `KeySigningKeyMapInput` via: 

KeySigningKeyMap{ "key": KeySigningKeyArgs{...} }

type KeySigningKeyMapOutput added in v3.28.0 

type KeySigningKeyMapOutput struct{ *pulumi.OutputState }

func (KeySigningKeyMapOutput) ElementType added in v3.28.0 

func (KeySigningKeyMapOutput) ElementType() reflect.Type

func (KeySigningKeyMapOutput) MapIndex added in v3.28.0 

func (o KeySigningKeyMapOutput) MapIndex(k pulumi.StringInput) KeySigningKeyOutput

func (KeySigningKeyMapOutput) ToKeySigningKeyMapOutput added in v3.28.0 

func (o KeySigningKeyMapOutput) ToKeySigningKeyMapOutput() KeySigningKeyMapOutput

func (KeySigningKeyMapOutput) ToKeySigningKeyMapOutputWithContext added in v3.28.0 

func (o KeySigningKeyMapOutput) ToKeySigningKeyMapOutputWithContext(ctx context.Context) KeySigningKeyMapOutput

type KeySigningKeyOutput added in v3.28.0 

type KeySigningKeyOutput struct {
	*pulumi.OutputState
}

func (KeySigningKeyOutput) ElementType added in v3.28.0 

func (KeySigningKeyOutput) ElementType() reflect.Type

func (KeySigningKeyOutput) ToKeySigningKeyOutput added in v3.28.0 

func (o KeySigningKeyOutput) ToKeySigningKeyOutput() KeySigningKeyOutput

func (KeySigningKeyOutput) ToKeySigningKeyOutputWithContext added in v3.28.0 

func (o KeySigningKeyOutput) ToKeySigningKeyOutputWithContext(ctx context.Context) KeySigningKeyOutput

func (KeySigningKeyOutput) ToKeySigningKeyPtrOutput added in v3.28.0 

func (o KeySigningKeyOutput) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (KeySigningKeyOutput) ToKeySigningKeyPtrOutputWithContext added in v3.28.0 

func (o KeySigningKeyOutput) ToKeySigningKeyPtrOutputWithContext(ctx context.Context) KeySigningKeyPtrOutput

type KeySigningKeyPtrInput added in v3.28.0 

type KeySigningKeyPtrInput interface {
	pulumi.Input

	ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput
	ToKeySigningKeyPtrOutputWithContext(ctx context.Context) KeySigningKeyPtrOutput
}

type KeySigningKeyPtrOutput added in v3.28.0 

type KeySigningKeyPtrOutput struct {
	*pulumi.OutputState
}

func (KeySigningKeyPtrOutput) ElementType added in v3.28.0 

func (KeySigningKeyPtrOutput) ElementType() reflect.Type

func (KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutput added in v3.28.0 

func (o KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutputWithContext added in v3.28.0 

func (o KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutputWithContext(ctx context.Context) KeySigningKeyPtrOutput

type KeySigningKeyState added in v3.28.0 

type KeySigningKeyState struct {
	// A string used to represent the delegation signer digest algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.3](https://tools.ietf.org/html/rfc8624#section-3.3).
	DigestAlgorithmMnemonic pulumi.StringPtrInput
	// An integer used to represent the delegation signer digest algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.3](https://tools.ietf.org/html/rfc8624#section-3.3).
	DigestAlgorithmType pulumi.IntPtrInput
	// A cryptographic digest of a DNSKEY resource record (RR). DNSKEY records are used to publish the public key that resolvers can use to verify DNSSEC signatures that are used to secure certain kinds of information provided by the DNS system.
	DigestValue pulumi.StringPtrInput
	// A string that represents a DNSKEY record.
	DnskeyRecord pulumi.StringPtrInput
	// A string that represents a delegation signer (DS) record.
	DsRecord pulumi.StringPtrInput
	// An integer that specifies how the key is used. For key-signing key (KSK), this value is always 257.
	Flag pulumi.IntPtrInput
	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringPtrInput
	// Amazon Resource Name (ARN) of the Key Management Service (KMS) Key. This must be unique for each key-signing key (KSK) in a single hosted zone. This key must be in the `us-east-1` Region and meet certain requirements, which are described in the [Route 53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-configuring-dnssec-cmk-requirements.html) and [Route 53 API Reference](https://docs.aws.amazon.com/Route53/latest/APIReference/API_CreateKeySigningKey.html).
	KeyManagementServiceArn pulumi.StringPtrInput
	// An integer used to identify the DNSSEC record for the domain name. The process used to calculate the value is described in [RFC-4034 Appendix B](https://tools.ietf.org/rfc/rfc4034.txt).
	KeyTag pulumi.IntPtrInput
	// Name of the key-signing key (KSK). Must be unique for each key-singing key in the same hosted zone.
	Name pulumi.StringPtrInput
	// The public key, represented as a Base64 encoding, as required by [RFC-4034 Page 5](https://tools.ietf.org/rfc/rfc4034.txt).
	PublicKey pulumi.StringPtrInput
	// A string used to represent the signing algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.1](https://tools.ietf.org/html/rfc8624#section-3.1).
	SigningAlgorithmMnemonic pulumi.StringPtrInput
	// An integer used to represent the signing algorithm. This value must follow the guidelines provided by [RFC-8624 Section 3.1](https://tools.ietf.org/html/rfc8624#section-3.1).
	SigningAlgorithmType pulumi.IntPtrInput
	// Status of the key-signing key (KSK). Valid values: `ACTIVE`, `INACTIVE`. Defaults to `ACTIVE`.
	Status pulumi.StringPtrInput
}

func (KeySigningKeyState) ElementType added in v3.28.0 

func (KeySigningKeyState) ElementType() reflect.Type

type LookupDelegationSetArgs 

type LookupDelegationSetArgs struct {
	// The Hosted Zone id of the desired delegation set.
	Id string `pulumi:"id"`
}

A collection of arguments for invoking getDelegationSet.

type LookupDelegationSetResult 

type LookupDelegationSetResult struct {
	CallerReference string   `pulumi:"callerReference"`
	Id              string   `pulumi:"id"`
	NameServers     []string `pulumi:"nameServers"`
}

A collection of values returned by getDelegationSet.

func LookupDelegationSet 

func LookupDelegationSet(ctx *pulumi.Context, args *LookupDelegationSetArgs, opts ...pulumi.InvokeOption) (*LookupDelegationSetResult, error)

`route53.DelegationSet` provides details about a specific Route 53 Delegation Set.

This data source allows to find a list of name servers associated with a specific delegation set.

## Example Usage

The following example shows how to get a delegation set from its id.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.LookupDelegationSet(ctx, &route53.LookupDelegationSetArgs{
			Id: "MQWGHCBFAKEID",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupResolverEndpointArgs added in v3.12.0 

type LookupResolverEndpointArgs struct {
	// One or more name/value pairs to use as filters. There are
	// several valid keys, for a full reference, check out
	// [Route53resolver Filter value in the AWS API reference][1].
	Filters []GetResolverEndpointFilter `pulumi:"filters"`
	// The ID of the Route53 Resolver Endpoint.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
}

A collection of arguments for invoking getResolverEndpoint.

type LookupResolverEndpointResult added in v3.12.0 

type LookupResolverEndpointResult struct {
	Arn       string                      `pulumi:"arn"`
	Direction string                      `pulumi:"direction"`
	Filters   []GetResolverEndpointFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id                 string   `pulumi:"id"`
	IpAddresses        []string `pulumi:"ipAddresses"`
	Name               string   `pulumi:"name"`
	ResolverEndpointId *string  `pulumi:"resolverEndpointId"`
	Status             string   `pulumi:"status"`
	VpcId              string   `pulumi:"vpcId"`
}

A collection of values returned by getResolverEndpoint.

func LookupResolverEndpoint added in v3.12.0 

func LookupResolverEndpoint(ctx *pulumi.Context, args *LookupResolverEndpointArgs, opts ...pulumi.InvokeOption) (*LookupResolverEndpointResult, error)

`route53.ResolverEndpoint` provides details about a specific Route53 Resolver Endpoint.

This data source allows to find a list of IPaddresses associated with a specific Route53 Resolver Endpoint.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "rslvr-in-1abc2345ef678g91h"
		_, err := route53.LookupResolverEndpoint(ctx, &route53.LookupResolverEndpointArgs{
			ResolverEndpointId: &opt0,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.LookupResolverEndpoint(ctx, &route53.LookupResolverEndpointArgs{
			Filters: []route53.GetResolverEndpointFilter{
				route53.GetResolverEndpointFilter{
					Name: "NAME",
					Values: []string{
						"MyResolverExampleName",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupResolverRuleArgs 

type LookupResolverRuleArgs struct {
	// The domain name the desired resolver rule forwards DNS queries for. Conflicts with `resolverRuleId`.
	DomainName *string `pulumi:"domainName"`
	// The friendly name of the desired resolver rule. Conflicts with `resolverRuleId`.
	Name *string `pulumi:"name"`
	// The ID of the outbound resolver endpoint of the desired resolver rule. Conflicts with `resolverRuleId`.
	ResolverEndpointId *string `pulumi:"resolverEndpointId"`
	// The ID of the desired resolver rule. Conflicts with `domainName`, `name`, `resolverEndpointId` and `ruleType`.
	ResolverRuleId *string `pulumi:"resolverRuleId"`
	// The rule type of the desired resolver rule. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`. Conflicts with `resolverRuleId`.
	RuleType *string `pulumi:"ruleType"`
	// A map of tags assigned to the resolver rule.
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getResolverRule.

type LookupResolverRuleResult 

type LookupResolverRuleResult struct {
	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn        string `pulumi:"arn"`
	DomainName string `pulumi:"domainName"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId            string `pulumi:"ownerId"`
	ResolverEndpointId string `pulumi:"resolverEndpointId"`
	ResolverRuleId     string `pulumi:"resolverRuleId"`
	RuleType           string `pulumi:"ruleType"`
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus string `pulumi:"shareStatus"`
	// A map of tags assigned to the resolver rule.
	Tags map[string]string `pulumi:"tags"`
}

A collection of values returned by getResolverRule.

func LookupResolverRule 

func LookupResolverRule(ctx *pulumi.Context, args *LookupResolverRuleArgs, opts ...pulumi.InvokeOption) (*LookupResolverRuleResult, error)

`route53.ResolverRule` provides details about a specific Route53 Resolver rule.

## Example Usage

The following example shows how to get a Route53 Resolver rule based on its associated domain name and rule type.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "subdomain.example.com"
		opt1 := "SYSTEM"
		_, err := route53.LookupResolverRule(ctx, &route53.LookupResolverRuleArgs{
			DomainName: &opt0,
			RuleType:   &opt1,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupZoneArgs 

type LookupZoneArgs struct {
	// The Hosted Zone name of the desired Hosted Zone.
	Name *string `pulumi:"name"`
	// Used with `name` field to get a private Hosted Zone.
	PrivateZone *bool `pulumi:"privateZone"`
	// The number of Record Set in the Hosted Zone.
	ResourceRecordSetCount *int `pulumi:"resourceRecordSetCount"`
	// Used with `name` field. A map of tags, each pair of which must exactly match a pair on the desired Hosted Zone.
	Tags map[string]string `pulumi:"tags"`
	// Used with `name` field to get a private Hosted Zone associated with the vpcId (in this case, privateZone is not mandatory).
	VpcId *string `pulumi:"vpcId"`
	// The Hosted Zone id of the desired Hosted Zone.
	ZoneId *string `pulumi:"zoneId"`
}

A collection of arguments for invoking getZone.

type LookupZoneResult 

type LookupZoneResult struct {
	// Caller Reference of the Hosted Zone.
	CallerReference string `pulumi:"callerReference"`
	// The comment field of the Hosted Zone.
	Comment string `pulumi:"comment"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The description provided by the service that created the Hosted Zone (e.g. `arn:aws:servicediscovery:us-east-1:1234567890:namespace/ns-xxxxxxxxxxxxxxxx`).
	LinkedServiceDescription string `pulumi:"linkedServiceDescription"`
	// The service that created the Hosted Zone (e.g. `servicediscovery.amazonaws.com`).
	LinkedServicePrincipal string `pulumi:"linkedServicePrincipal"`
	Name                   string `pulumi:"name"`
	// The list of DNS name servers for the Hosted Zone.
	NameServers []string `pulumi:"nameServers"`
	PrivateZone *bool    `pulumi:"privateZone"`
	// The number of Record Set in the Hosted Zone.
	ResourceRecordSetCount int               `pulumi:"resourceRecordSetCount"`
	Tags                   map[string]string `pulumi:"tags"`
	VpcId                  string            `pulumi:"vpcId"`
	ZoneId                 string            `pulumi:"zoneId"`
}

A collection of values returned by getZone.

func LookupZone 

func LookupZone(ctx *pulumi.Context, args *LookupZoneArgs, opts ...pulumi.InvokeOption) (*LookupZoneResult, error)

`route53.Zone` provides details about a specific Route 53 Hosted Zone.

This data source allows to find a Hosted Zone ID given Hosted Zone name and certain search criteria.

## Example Usage

The following example shows how to get a Hosted Zone from its name and from this data how to create a Record Set.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "test.com."
		opt1 := true
		selected, err := route53.LookupZone(ctx, &route53.LookupZoneArgs{
			Name:        &opt0,
			PrivateZone: &opt1,
		}, nil)
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www", &route53.RecordArgs{
			ZoneId: pulumi.String(selected.ZoneId),
			Name:   pulumi.String(fmt.Sprintf("%v%v", "www.", selected.Name)),
			Type:   pulumi.String("A"),
			Ttl:    pulumi.Int(300),
			Records: pulumi.StringArray{
				pulumi.String("10.0.0.1"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

type QueryLog 

type QueryLog struct {
	pulumi.CustomResourceState

	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringOutput `pulumi:"cloudwatchLogGroupArn"`
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Provides a Route53 query logging configuration resource.

> **NOTE:** There are restrictions on the configuration of query logging. Notably, the CloudWatch log group must be in the `us-east-1` region, a permissive CloudWatch log resource policy must be in place, and the Route53 hosted zone must be public. See [Configuring Logging for DNS Queries](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/query-logs.html?console_help=true#query-logs-configuring) for additional details.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "us_east_1", &providers.awsArgs{
			Region: pulumi.String("us-east-1"),
		})
		if err != nil {
			return err
		}
		awsRoute53ExampleCom, err := cloudwatch.NewLogGroup(ctx, "awsRoute53ExampleCom", &cloudwatch.LogGroupArgs{
			RetentionInDays: pulumi.Int(30),
		}, pulumi.Provider(aws.Us-east-1))
		if err != nil {
			return err
		}
		route53_query_logging_policyPolicyDocument, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				iam.GetPolicyDocumentStatement{
					Actions: []string{
						"logs:CreateLogStream",
						"logs:PutLogEvents",
					},
					Resources: []string{
						"arn:aws:logs:*:*:log-group:/aws/route53/*",
					},
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						iam.GetPolicyDocumentStatementPrincipal{
							Identifiers: []string{
								"route53.amazonaws.com",
							},
							Type: "Service",
						},
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = cloudwatch.NewLogResourcePolicy(ctx, "route53_query_logging_policyLogResourcePolicy", &cloudwatch.LogResourcePolicyArgs{
			PolicyDocument: pulumi.String(route53_query_logging_policyPolicyDocument.Json),
			PolicyName:     pulumi.String("route53-query-logging-policy"),
		}, pulumi.Provider(aws.Us-east-1))
		if err != nil {
			return err
		}
		exampleComZone, err := route53.NewZone(ctx, "exampleComZone", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewQueryLog(ctx, "exampleComQueryLog", &route53.QueryLogArgs{
			CloudwatchLogGroupArn: awsRoute53ExampleCom.Arn,
			ZoneId:                exampleComZone.ZoneId,
		}, pulumi.DependsOn([]pulumi.Resource{
			route53_query_logging_policyLogResourcePolicy,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 query logging configurations can be imported using their ID, e.g.

```sh 

$ pulumi import aws:route53/queryLog:QueryLog example_com xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

```

func GetQueryLog 

func GetQueryLog(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *QueryLogState, opts ...pulumi.ResourceOption) (*QueryLog, error)

GetQueryLog gets an existing QueryLog resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewQueryLog 

func NewQueryLog(ctx *pulumi.Context,
	name string, args *QueryLogArgs, opts ...pulumi.ResourceOption) (*QueryLog, error)

NewQueryLog registers a new resource with the given unique name, arguments, and options.

func (*QueryLog) ElementType added in v3.13.0 

func (*QueryLog) ElementType() reflect.Type

func (*QueryLog) ToQueryLogOutput added in v3.13.0 

func (i *QueryLog) ToQueryLogOutput() QueryLogOutput

func (*QueryLog) ToQueryLogOutputWithContext added in v3.13.0 

func (i *QueryLog) ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput

func (*QueryLog) ToQueryLogPtrOutput added in v3.25.0 

func (i *QueryLog) ToQueryLogPtrOutput() QueryLogPtrOutput

func (*QueryLog) ToQueryLogPtrOutputWithContext added in v3.25.0 

func (i *QueryLog) ToQueryLogPtrOutputWithContext(ctx context.Context) QueryLogPtrOutput

type QueryLogArgs 

type QueryLogArgs struct {
	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringInput
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a QueryLog resource.

func (QueryLogArgs) ElementType 

func (QueryLogArgs) ElementType() reflect.Type

type QueryLogArray added in v3.25.0 

type QueryLogArray []QueryLogInput

func (QueryLogArray) ElementType added in v3.25.0 

func (QueryLogArray) ElementType() reflect.Type

func (QueryLogArray) ToQueryLogArrayOutput added in v3.25.0 

func (i QueryLogArray) ToQueryLogArrayOutput() QueryLogArrayOutput

func (QueryLogArray) ToQueryLogArrayOutputWithContext added in v3.25.0 

func (i QueryLogArray) ToQueryLogArrayOutputWithContext(ctx context.Context) QueryLogArrayOutput

type QueryLogArrayInput added in v3.25.0 

type QueryLogArrayInput interface {
	pulumi.Input

	ToQueryLogArrayOutput() QueryLogArrayOutput
	ToQueryLogArrayOutputWithContext(context.Context) QueryLogArrayOutput
}

QueryLogArrayInput is an input type that accepts QueryLogArray and QueryLogArrayOutput values. You can construct a concrete instance of `QueryLogArrayInput` via: 

QueryLogArray{ QueryLogArgs{...} }

type QueryLogArrayOutput added in v3.25.0 

type QueryLogArrayOutput struct{ *pulumi.OutputState }

func (QueryLogArrayOutput) ElementType added in v3.25.0 

func (QueryLogArrayOutput) ElementType() reflect.Type

func (QueryLogArrayOutput) Index added in v3.25.0 

func (o QueryLogArrayOutput) Index(i pulumi.IntInput) QueryLogOutput

func (QueryLogArrayOutput) ToQueryLogArrayOutput added in v3.25.0 

func (o QueryLogArrayOutput) ToQueryLogArrayOutput() QueryLogArrayOutput

func (QueryLogArrayOutput) ToQueryLogArrayOutputWithContext added in v3.25.0 

func (o QueryLogArrayOutput) ToQueryLogArrayOutputWithContext(ctx context.Context) QueryLogArrayOutput

type QueryLogInput added in v3.13.0 

type QueryLogInput interface {
	pulumi.Input

	ToQueryLogOutput() QueryLogOutput
	ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput
}

type QueryLogMap added in v3.25.0 

type QueryLogMap map[string]QueryLogInput

func (QueryLogMap) ElementType added in v3.25.0 

func (QueryLogMap) ElementType() reflect.Type

func (QueryLogMap) ToQueryLogMapOutput added in v3.25.0 

func (i QueryLogMap) ToQueryLogMapOutput() QueryLogMapOutput

func (QueryLogMap) ToQueryLogMapOutputWithContext added in v3.25.0 

func (i QueryLogMap) ToQueryLogMapOutputWithContext(ctx context.Context) QueryLogMapOutput

type QueryLogMapInput added in v3.25.0 

type QueryLogMapInput interface {
	pulumi.Input

	ToQueryLogMapOutput() QueryLogMapOutput
	ToQueryLogMapOutputWithContext(context.Context) QueryLogMapOutput
}

QueryLogMapInput is an input type that accepts QueryLogMap and QueryLogMapOutput values. You can construct a concrete instance of `QueryLogMapInput` via: 

QueryLogMap{ "key": QueryLogArgs{...} }

type QueryLogMapOutput added in v3.25.0 

type QueryLogMapOutput struct{ *pulumi.OutputState }

func (QueryLogMapOutput) ElementType added in v3.25.0 

func (QueryLogMapOutput) ElementType() reflect.Type

func (QueryLogMapOutput) MapIndex added in v3.25.0 

func (o QueryLogMapOutput) MapIndex(k pulumi.StringInput) QueryLogOutput

func (QueryLogMapOutput) ToQueryLogMapOutput added in v3.25.0 

func (o QueryLogMapOutput) ToQueryLogMapOutput() QueryLogMapOutput

func (QueryLogMapOutput) ToQueryLogMapOutputWithContext added in v3.25.0 

func (o QueryLogMapOutput) ToQueryLogMapOutputWithContext(ctx context.Context) QueryLogMapOutput

type QueryLogOutput added in v3.13.0 

type QueryLogOutput struct {
	*pulumi.OutputState
}

func (QueryLogOutput) ElementType added in v3.13.0 

func (QueryLogOutput) ElementType() reflect.Type

func (QueryLogOutput) ToQueryLogOutput added in v3.13.0 

func (o QueryLogOutput) ToQueryLogOutput() QueryLogOutput

func (QueryLogOutput) ToQueryLogOutputWithContext added in v3.13.0 

func (o QueryLogOutput) ToQueryLogOutputWithContext(ctx context.Context) QueryLogOutput

func (QueryLogOutput) ToQueryLogPtrOutput added in v3.25.0 

func (o QueryLogOutput) ToQueryLogPtrOutput() QueryLogPtrOutput

func (QueryLogOutput) ToQueryLogPtrOutputWithContext added in v3.25.0 

func (o QueryLogOutput) ToQueryLogPtrOutputWithContext(ctx context.Context) QueryLogPtrOutput

type QueryLogPtrInput added in v3.25.0 

type QueryLogPtrInput interface {
	pulumi.Input

	ToQueryLogPtrOutput() QueryLogPtrOutput
	ToQueryLogPtrOutputWithContext(ctx context.Context) QueryLogPtrOutput
}

type QueryLogPtrOutput added in v3.25.0 

type QueryLogPtrOutput struct {
	*pulumi.OutputState
}

func (QueryLogPtrOutput) ElementType added in v3.25.0 

func (QueryLogPtrOutput) ElementType() reflect.Type

func (QueryLogPtrOutput) ToQueryLogPtrOutput added in v3.25.0 

func (o QueryLogPtrOutput) ToQueryLogPtrOutput() QueryLogPtrOutput

func (QueryLogPtrOutput) ToQueryLogPtrOutputWithContext added in v3.25.0 

func (o QueryLogPtrOutput) ToQueryLogPtrOutputWithContext(ctx context.Context) QueryLogPtrOutput

type QueryLogState 

type QueryLogState struct {
	// CloudWatch log group ARN to send query logs.
	CloudwatchLogGroupArn pulumi.StringPtrInput
	// Route53 hosted zone ID to enable query logs.
	ZoneId pulumi.StringPtrInput
}

func (QueryLogState) ElementType 

func (QueryLogState) ElementType() reflect.Type

type Record 

type Record struct {
	pulumi.CustomResourceState

	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayOutput `pulumi:"aliases"`
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolOutput `pulumi:"allowOverwrite"`
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayOutput `pulumi:"failoverRoutingPolicies"`
	// [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) built using the zone domain and `name`.
	Fqdn pulumi.StringOutput `pulumi:"fqdn"`
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayOutput `pulumi:"geolocationRoutingPolicies"`
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrOutput `pulumi:"healthCheckId"`
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayOutput `pulumi:"latencyRoutingPolicies"`
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrOutput `pulumi:"multivalueAnswerRoutingPolicy"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringOutput `pulumi:"name"`
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayOutput `pulumi:"records"`
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrOutput `pulumi:"setIdentifier"`
	// The TTL of the record.
	Ttl pulumi.IntPtrOutput `pulumi:"ttl"`
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringOutput `pulumi:"type"`
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayOutput `pulumi:"weightedRoutingPolicies"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Provides a Route53 record resource.

## Example Usage ### Weighted routing policy Other routing policies are configured similarly. See [AWS Route53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html) for details.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewRecord(ctx, "www_dev", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("www"),
			Type:   pulumi.String("CNAME"),
			Ttl:    pulumi.Int(5),
			WeightedRoutingPolicies: route53.RecordWeightedRoutingPolicyArray{
				&route53.RecordWeightedRoutingPolicyArgs{
					Weight: pulumi.Int(10),
				},
			},
			SetIdentifier: pulumi.String("dev"),
			Records: pulumi.StringArray{
				pulumi.String("dev.example.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www_live", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("www"),
			Type:   pulumi.String("CNAME"),
			Ttl:    pulumi.Int(5),
			WeightedRoutingPolicies: route53.RecordWeightedRoutingPolicyArray{
				&route53.RecordWeightedRoutingPolicyArgs{
					Weight: pulumi.Int(90),
				},
			},
			SetIdentifier: pulumi.String("live"),
			Records: pulumi.StringArray{
				pulumi.String("live.example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Alias record See [related part of AWS Route53 Developer Guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html) to understand differences between alias and non-alias records.

TTL for all alias records is [60 seconds](https://aws.amazon.com/route53/faqs/#dns_failover_do_i_need_to_adjust), you cannot change this, therefore `ttl` has to be omitted in alias records.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/elb"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := elb.NewLoadBalancer(ctx, "main", &elb.LoadBalancerArgs{
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1c"),
			},
			Listeners: elb.LoadBalancerListenerArray{
				&elb.LoadBalancerListenerArgs{
					InstancePort:     pulumi.Int(80),
					InstanceProtocol: pulumi.String("http"),
					LbPort:           pulumi.Int(80),
					LbProtocol:       pulumi.String("http"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "www", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("example.com"),
			Type:   pulumi.String("A"),
			Aliases: route53.RecordAliasArray{
				&route53.RecordAliasArgs{
					Name:                 main.DnsName,
					ZoneId:               main.ZoneId,
					EvaluateTargetHealth: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### NS and SOA Record Management

When creating Route 53 zones, the `NS` and `SOA` records for the zone are automatically created. Enabling the `allowOverwrite` argument will allow managing these records in a single deployment without the requirement for `import`.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleZone, err := route53.NewZone(ctx, "exampleZone", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "exampleRecord", &route53.RecordArgs{
			AllowOverwrite: pulumi.Bool(true),
			Name:           pulumi.String("test.example.com"),
			Ttl:            pulumi.Int(30),
			Type:           pulumi.String("NS"),
			ZoneId:         exampleZone.ZoneId,
			Records: pulumi.StringArray{
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[0], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[1], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[2], nil
				}).(pulumi.StringOutput),
				exampleZone.NameServers.ApplyT(func(nameServers []string) (string, error) {
					return nameServers[3], nil
				}).(pulumi.StringOutput),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Records can be imported using ID of the record, which is the zone identifier, record name, and record type, separated by underscores (`_`). e.g.

```sh 

$ pulumi import aws:route53/record:Record myrecord Z4KAPRWWNC7JR_dev.example.com_NS

``` 

If the record also contains a delegated set identifier, it can be appended

```sh 

$ pulumi import aws:route53/record:Record myrecord Z4KAPRWWNC7JR_dev.example.com_NS_dev

```

func GetRecord 

func GetRecord(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RecordState, opts ...pulumi.ResourceOption) (*Record, error)

GetRecord gets an existing Record resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRecord 

func NewRecord(ctx *pulumi.Context,
	name string, args *RecordArgs, opts ...pulumi.ResourceOption) (*Record, error)

NewRecord registers a new resource with the given unique name, arguments, and options.

func (*Record) ElementType added in v3.13.0 

func (*Record) ElementType() reflect.Type

func (*Record) ToRecordOutput added in v3.13.0 

func (i *Record) ToRecordOutput() RecordOutput

func (*Record) ToRecordOutputWithContext added in v3.13.0 

func (i *Record) ToRecordOutputWithContext(ctx context.Context) RecordOutput

func (*Record) ToRecordPtrOutput added in v3.25.0 

func (i *Record) ToRecordPtrOutput() RecordPtrOutput

func (*Record) ToRecordPtrOutputWithContext added in v3.25.0 

func (i *Record) ToRecordPtrOutputWithContext(ctx context.Context) RecordPtrOutput

type RecordAlias 

type RecordAlias struct {
	// Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).
	EvaluateTargetHealth bool `pulumi:"evaluateTargetHealth"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name string `pulumi:"name"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId string `pulumi:"zoneId"`
}

type RecordAliasArgs 

type RecordAliasArgs struct {
	// Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).
	EvaluateTargetHealth pulumi.BoolInput `pulumi:"evaluateTargetHealth"`
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringInput `pulumi:"name"`
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringInput `pulumi:"zoneId"`
}

func (RecordAliasArgs) ElementType 

func (RecordAliasArgs) ElementType() reflect.Type

func (RecordAliasArgs) ToRecordAliasOutput 

func (i RecordAliasArgs) ToRecordAliasOutput() RecordAliasOutput

func (RecordAliasArgs) ToRecordAliasOutputWithContext 

func (i RecordAliasArgs) ToRecordAliasOutputWithContext(ctx context.Context) RecordAliasOutput

type RecordAliasArray 

type RecordAliasArray []RecordAliasInput

func (RecordAliasArray) ElementType 

func (RecordAliasArray) ElementType() reflect.Type

func (RecordAliasArray) ToRecordAliasArrayOutput 

func (i RecordAliasArray) ToRecordAliasArrayOutput() RecordAliasArrayOutput

func (RecordAliasArray) ToRecordAliasArrayOutputWithContext 

func (i RecordAliasArray) ToRecordAliasArrayOutputWithContext(ctx context.Context) RecordAliasArrayOutput

type RecordAliasArrayInput 

type RecordAliasArrayInput interface {
	pulumi.Input

	ToRecordAliasArrayOutput() RecordAliasArrayOutput
	ToRecordAliasArrayOutputWithContext(context.Context) RecordAliasArrayOutput
}

RecordAliasArrayInput is an input type that accepts RecordAliasArray and RecordAliasArrayOutput values. You can construct a concrete instance of `RecordAliasArrayInput` via: 

RecordAliasArray{ RecordAliasArgs{...} }

type RecordAliasArrayOutput 

type RecordAliasArrayOutput struct{ *pulumi.OutputState }

func (RecordAliasArrayOutput) ElementType 

func (RecordAliasArrayOutput) ElementType() reflect.Type

func (RecordAliasArrayOutput) Index 

func (o RecordAliasArrayOutput) Index(i pulumi.IntInput) RecordAliasOutput

func (RecordAliasArrayOutput) ToRecordAliasArrayOutput 

func (o RecordAliasArrayOutput) ToRecordAliasArrayOutput() RecordAliasArrayOutput

func (RecordAliasArrayOutput) ToRecordAliasArrayOutputWithContext 

func (o RecordAliasArrayOutput) ToRecordAliasArrayOutputWithContext(ctx context.Context) RecordAliasArrayOutput

type RecordAliasInput 

type RecordAliasInput interface {
	pulumi.Input

	ToRecordAliasOutput() RecordAliasOutput
	ToRecordAliasOutputWithContext(context.Context) RecordAliasOutput
}

RecordAliasInput is an input type that accepts RecordAliasArgs and RecordAliasOutput values. You can construct a concrete instance of `RecordAliasInput` via: 

RecordAliasArgs{...}

type RecordAliasOutput 

type RecordAliasOutput struct{ *pulumi.OutputState }

func (RecordAliasOutput) ElementType 

func (RecordAliasOutput) ElementType() reflect.Type

func (RecordAliasOutput) EvaluateTargetHealth 

func (o RecordAliasOutput) EvaluateTargetHealth() pulumi.BoolOutput

Set to `true` if you want Route 53 to determine whether to respond to DNS queries using this resource record set by checking the health of the resource record set. Some resources have special requirements, see [related part of documentation](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values.html#rrsets-values-alias-evaluate-target-health).

func (RecordAliasOutput) Name 

func (o RecordAliasOutput) Name() pulumi.StringOutput

DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.

func (RecordAliasOutput) ToRecordAliasOutput 

func (o RecordAliasOutput) ToRecordAliasOutput() RecordAliasOutput

func (RecordAliasOutput) ToRecordAliasOutputWithContext 

func (o RecordAliasOutput) ToRecordAliasOutputWithContext(ctx context.Context) RecordAliasOutput

func (RecordAliasOutput) ZoneId 

func (o RecordAliasOutput) ZoneId() pulumi.StringOutput

Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.

type RecordArgs 

type RecordArgs struct {
	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayInput
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolPtrInput
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayInput
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayInput
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrInput
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayInput
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrInput
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringInput
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayInput
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrInput
	// The TTL of the record.
	Ttl pulumi.IntPtrInput
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringInput
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayInput
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a Record resource.

func (RecordArgs) ElementType 

func (RecordArgs) ElementType() reflect.Type

type RecordArray added in v3.25.0 

type RecordArray []RecordInput

func (RecordArray) ElementType added in v3.25.0 

func (RecordArray) ElementType() reflect.Type

func (RecordArray) ToRecordArrayOutput added in v3.25.0 

func (i RecordArray) ToRecordArrayOutput() RecordArrayOutput

func (RecordArray) ToRecordArrayOutputWithContext added in v3.25.0 

func (i RecordArray) ToRecordArrayOutputWithContext(ctx context.Context) RecordArrayOutput

type RecordArrayInput added in v3.25.0 

type RecordArrayInput interface {
	pulumi.Input

	ToRecordArrayOutput() RecordArrayOutput
	ToRecordArrayOutputWithContext(context.Context) RecordArrayOutput
}

RecordArrayInput is an input type that accepts RecordArray and RecordArrayOutput values. You can construct a concrete instance of `RecordArrayInput` via: 

RecordArray{ RecordArgs{...} }

type RecordArrayOutput added in v3.25.0 

type RecordArrayOutput struct{ *pulumi.OutputState }

func (RecordArrayOutput) ElementType added in v3.25.0 

func (RecordArrayOutput) ElementType() reflect.Type

func (RecordArrayOutput) Index added in v3.25.0 

func (o RecordArrayOutput) Index(i pulumi.IntInput) RecordOutput

func (RecordArrayOutput) ToRecordArrayOutput added in v3.25.0 

func (o RecordArrayOutput) ToRecordArrayOutput() RecordArrayOutput

func (RecordArrayOutput) ToRecordArrayOutputWithContext added in v3.25.0 

func (o RecordArrayOutput) ToRecordArrayOutputWithContext(ctx context.Context) RecordArrayOutput

type RecordFailoverRoutingPolicy 

type RecordFailoverRoutingPolicy struct {
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type string `pulumi:"type"`
}

type RecordFailoverRoutingPolicyArgs 

type RecordFailoverRoutingPolicyArgs struct {
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringInput `pulumi:"type"`
}

func (RecordFailoverRoutingPolicyArgs) ElementType 

func (RecordFailoverRoutingPolicyArgs) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutput 

func (i RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutputWithContext 

func (i RecordFailoverRoutingPolicyArgs) ToRecordFailoverRoutingPolicyOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyOutput

type RecordFailoverRoutingPolicyArray 

type RecordFailoverRoutingPolicyArray []RecordFailoverRoutingPolicyInput

func (RecordFailoverRoutingPolicyArray) ElementType 

func (RecordFailoverRoutingPolicyArray) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutput 

func (i RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput

func (RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutputWithContext 

func (i RecordFailoverRoutingPolicyArray) ToRecordFailoverRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyArrayOutput

type RecordFailoverRoutingPolicyArrayInput 

type RecordFailoverRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput
	ToRecordFailoverRoutingPolicyArrayOutputWithContext(context.Context) RecordFailoverRoutingPolicyArrayOutput
}

RecordFailoverRoutingPolicyArrayInput is an input type that accepts RecordFailoverRoutingPolicyArray and RecordFailoverRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordFailoverRoutingPolicyArrayInput` via: 

RecordFailoverRoutingPolicyArray{ RecordFailoverRoutingPolicyArgs{...} }

type RecordFailoverRoutingPolicyArrayOutput 

type RecordFailoverRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordFailoverRoutingPolicyArrayOutput) ElementType 

func (RecordFailoverRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyArrayOutput) Index 

func (o RecordFailoverRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutput 

func (o RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutput() RecordFailoverRoutingPolicyArrayOutput

func (RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutputWithContext 

func (o RecordFailoverRoutingPolicyArrayOutput) ToRecordFailoverRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyArrayOutput

type RecordFailoverRoutingPolicyInput 

type RecordFailoverRoutingPolicyInput interface {
	pulumi.Input

	ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput
	ToRecordFailoverRoutingPolicyOutputWithContext(context.Context) RecordFailoverRoutingPolicyOutput
}

RecordFailoverRoutingPolicyInput is an input type that accepts RecordFailoverRoutingPolicyArgs and RecordFailoverRoutingPolicyOutput values. You can construct a concrete instance of `RecordFailoverRoutingPolicyInput` via: 

RecordFailoverRoutingPolicyArgs{...}

type RecordFailoverRoutingPolicyOutput 

type RecordFailoverRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordFailoverRoutingPolicyOutput) ElementType 

func (RecordFailoverRoutingPolicyOutput) ElementType() reflect.Type

func (RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutput 

func (o RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutput() RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutputWithContext 

func (o RecordFailoverRoutingPolicyOutput) ToRecordFailoverRoutingPolicyOutputWithContext(ctx context.Context) RecordFailoverRoutingPolicyOutput

func (RecordFailoverRoutingPolicyOutput) Type 

func (o RecordFailoverRoutingPolicyOutput) Type() pulumi.StringOutput

`PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets

type RecordGeolocationRoutingPolicy 

type RecordGeolocationRoutingPolicy struct {
	// A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.
	Continent *string `pulumi:"continent"`
	// A two-character country code or `*` to indicate a default resource record set.
	Country *string `pulumi:"country"`
	// A subdivision code for a country.
	Subdivision *string `pulumi:"subdivision"`
}

type RecordGeolocationRoutingPolicyArgs 

type RecordGeolocationRoutingPolicyArgs struct {
	// A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.
	Continent pulumi.StringPtrInput `pulumi:"continent"`
	// A two-character country code or `*` to indicate a default resource record set.
	Country pulumi.StringPtrInput `pulumi:"country"`
	// A subdivision code for a country.
	Subdivision pulumi.StringPtrInput `pulumi:"subdivision"`
}

func (RecordGeolocationRoutingPolicyArgs) ElementType 

func (RecordGeolocationRoutingPolicyArgs) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutput 

func (i RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutputWithContext 

func (i RecordGeolocationRoutingPolicyArgs) ToRecordGeolocationRoutingPolicyOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyOutput

type RecordGeolocationRoutingPolicyArray 

type RecordGeolocationRoutingPolicyArray []RecordGeolocationRoutingPolicyInput

func (RecordGeolocationRoutingPolicyArray) ElementType 

func (RecordGeolocationRoutingPolicyArray) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutput 

func (i RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput

func (RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutputWithContext 

func (i RecordGeolocationRoutingPolicyArray) ToRecordGeolocationRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyArrayOutput

type RecordGeolocationRoutingPolicyArrayInput 

type RecordGeolocationRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput
	ToRecordGeolocationRoutingPolicyArrayOutputWithContext(context.Context) RecordGeolocationRoutingPolicyArrayOutput
}

RecordGeolocationRoutingPolicyArrayInput is an input type that accepts RecordGeolocationRoutingPolicyArray and RecordGeolocationRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordGeolocationRoutingPolicyArrayInput` via: 

RecordGeolocationRoutingPolicyArray{ RecordGeolocationRoutingPolicyArgs{...} }

type RecordGeolocationRoutingPolicyArrayOutput 

type RecordGeolocationRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordGeolocationRoutingPolicyArrayOutput) ElementType 

func (RecordGeolocationRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyArrayOutput) Index 

func (o RecordGeolocationRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutput 

func (o RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutput() RecordGeolocationRoutingPolicyArrayOutput

func (RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutputWithContext 

func (o RecordGeolocationRoutingPolicyArrayOutput) ToRecordGeolocationRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyArrayOutput

type RecordGeolocationRoutingPolicyInput 

type RecordGeolocationRoutingPolicyInput interface {
	pulumi.Input

	ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput
	ToRecordGeolocationRoutingPolicyOutputWithContext(context.Context) RecordGeolocationRoutingPolicyOutput
}

RecordGeolocationRoutingPolicyInput is an input type that accepts RecordGeolocationRoutingPolicyArgs and RecordGeolocationRoutingPolicyOutput values. You can construct a concrete instance of `RecordGeolocationRoutingPolicyInput` via: 

RecordGeolocationRoutingPolicyArgs{...}

type RecordGeolocationRoutingPolicyOutput 

type RecordGeolocationRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordGeolocationRoutingPolicyOutput) Continent 

func (o RecordGeolocationRoutingPolicyOutput) Continent() pulumi.StringPtrOutput

A two-letter continent code. See http://docs.aws.amazon.com/Route53/latest/APIReference/API_GetGeoLocation.html for code details. Either `continent` or `country` must be specified.

func (RecordGeolocationRoutingPolicyOutput) Country 

func (o RecordGeolocationRoutingPolicyOutput) Country() pulumi.StringPtrOutput

A two-character country code or `*` to indicate a default resource record set.

func (RecordGeolocationRoutingPolicyOutput) ElementType 

func (RecordGeolocationRoutingPolicyOutput) ElementType() reflect.Type

func (RecordGeolocationRoutingPolicyOutput) Subdivision 

func (o RecordGeolocationRoutingPolicyOutput) Subdivision() pulumi.StringPtrOutput

A subdivision code for a country.

func (RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutput 

func (o RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutput() RecordGeolocationRoutingPolicyOutput

func (RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutputWithContext 

func (o RecordGeolocationRoutingPolicyOutput) ToRecordGeolocationRoutingPolicyOutputWithContext(ctx context.Context) RecordGeolocationRoutingPolicyOutput

type RecordInput added in v3.13.0 

type RecordInput interface {
	pulumi.Input

	ToRecordOutput() RecordOutput
	ToRecordOutputWithContext(ctx context.Context) RecordOutput
}

type RecordLatencyRoutingPolicy 

type RecordLatencyRoutingPolicy struct {
	// An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency
	Region string `pulumi:"region"`
}

type RecordLatencyRoutingPolicyArgs 

type RecordLatencyRoutingPolicyArgs struct {
	// An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency
	Region pulumi.StringInput `pulumi:"region"`
}

func (RecordLatencyRoutingPolicyArgs) ElementType 

func (RecordLatencyRoutingPolicyArgs) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutput 

func (i RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutputWithContext 

func (i RecordLatencyRoutingPolicyArgs) ToRecordLatencyRoutingPolicyOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyOutput

type RecordLatencyRoutingPolicyArray 

type RecordLatencyRoutingPolicyArray []RecordLatencyRoutingPolicyInput

func (RecordLatencyRoutingPolicyArray) ElementType 

func (RecordLatencyRoutingPolicyArray) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutput 

func (i RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput

func (RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutputWithContext 

func (i RecordLatencyRoutingPolicyArray) ToRecordLatencyRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyArrayOutput

type RecordLatencyRoutingPolicyArrayInput 

type RecordLatencyRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput
	ToRecordLatencyRoutingPolicyArrayOutputWithContext(context.Context) RecordLatencyRoutingPolicyArrayOutput
}

RecordLatencyRoutingPolicyArrayInput is an input type that accepts RecordLatencyRoutingPolicyArray and RecordLatencyRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordLatencyRoutingPolicyArrayInput` via: 

RecordLatencyRoutingPolicyArray{ RecordLatencyRoutingPolicyArgs{...} }

type RecordLatencyRoutingPolicyArrayOutput 

type RecordLatencyRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordLatencyRoutingPolicyArrayOutput) ElementType 

func (RecordLatencyRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyArrayOutput) Index 

func (o RecordLatencyRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutput 

func (o RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutput() RecordLatencyRoutingPolicyArrayOutput

func (RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutputWithContext 

func (o RecordLatencyRoutingPolicyArrayOutput) ToRecordLatencyRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyArrayOutput

type RecordLatencyRoutingPolicyInput 

type RecordLatencyRoutingPolicyInput interface {
	pulumi.Input

	ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput
	ToRecordLatencyRoutingPolicyOutputWithContext(context.Context) RecordLatencyRoutingPolicyOutput
}

RecordLatencyRoutingPolicyInput is an input type that accepts RecordLatencyRoutingPolicyArgs and RecordLatencyRoutingPolicyOutput values. You can construct a concrete instance of `RecordLatencyRoutingPolicyInput` via: 

RecordLatencyRoutingPolicyArgs{...}

type RecordLatencyRoutingPolicyOutput 

type RecordLatencyRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordLatencyRoutingPolicyOutput) ElementType 

func (RecordLatencyRoutingPolicyOutput) ElementType() reflect.Type

func (RecordLatencyRoutingPolicyOutput) Region 

func (o RecordLatencyRoutingPolicyOutput) Region() pulumi.StringOutput

An AWS region from which to measure latency. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-latency

func (RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutput 

func (o RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutput() RecordLatencyRoutingPolicyOutput

func (RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutputWithContext 

func (o RecordLatencyRoutingPolicyOutput) ToRecordLatencyRoutingPolicyOutputWithContext(ctx context.Context) RecordLatencyRoutingPolicyOutput

type RecordMap added in v3.25.0 

type RecordMap map[string]RecordInput

func (RecordMap) ElementType added in v3.25.0 

func (RecordMap) ElementType() reflect.Type

func (RecordMap) ToRecordMapOutput added in v3.25.0 

func (i RecordMap) ToRecordMapOutput() RecordMapOutput

func (RecordMap) ToRecordMapOutputWithContext added in v3.25.0 

func (i RecordMap) ToRecordMapOutputWithContext(ctx context.Context) RecordMapOutput

type RecordMapInput added in v3.25.0 

type RecordMapInput interface {
	pulumi.Input

	ToRecordMapOutput() RecordMapOutput
	ToRecordMapOutputWithContext(context.Context) RecordMapOutput
}

RecordMapInput is an input type that accepts RecordMap and RecordMapOutput values. You can construct a concrete instance of `RecordMapInput` via: 

RecordMap{ "key": RecordArgs{...} }

type RecordMapOutput added in v3.25.0 

type RecordMapOutput struct{ *pulumi.OutputState }

func (RecordMapOutput) ElementType added in v3.25.0 

func (RecordMapOutput) ElementType() reflect.Type

func (RecordMapOutput) MapIndex added in v3.25.0 

func (o RecordMapOutput) MapIndex(k pulumi.StringInput) RecordOutput

func (RecordMapOutput) ToRecordMapOutput added in v3.25.0 

func (o RecordMapOutput) ToRecordMapOutput() RecordMapOutput

func (RecordMapOutput) ToRecordMapOutputWithContext added in v3.25.0 

func (o RecordMapOutput) ToRecordMapOutputWithContext(ctx context.Context) RecordMapOutput

type RecordOutput added in v3.13.0 

type RecordOutput struct {
	*pulumi.OutputState
}

func (RecordOutput) ElementType added in v3.13.0 

func (RecordOutput) ElementType() reflect.Type

func (RecordOutput) ToRecordOutput added in v3.13.0 

func (o RecordOutput) ToRecordOutput() RecordOutput

func (RecordOutput) ToRecordOutputWithContext added in v3.13.0 

func (o RecordOutput) ToRecordOutputWithContext(ctx context.Context) RecordOutput

func (RecordOutput) ToRecordPtrOutput added in v3.25.0 

func (o RecordOutput) ToRecordPtrOutput() RecordPtrOutput

func (RecordOutput) ToRecordPtrOutputWithContext added in v3.25.0 

func (o RecordOutput) ToRecordPtrOutputWithContext(ctx context.Context) RecordPtrOutput

type RecordPtrInput added in v3.25.0 

type RecordPtrInput interface {
	pulumi.Input

	ToRecordPtrOutput() RecordPtrOutput
	ToRecordPtrOutputWithContext(ctx context.Context) RecordPtrOutput
}

type RecordPtrOutput added in v3.25.0 

type RecordPtrOutput struct {
	*pulumi.OutputState
}

func (RecordPtrOutput) ElementType added in v3.25.0 

func (RecordPtrOutput) ElementType() reflect.Type

func (RecordPtrOutput) ToRecordPtrOutput added in v3.25.0 

func (o RecordPtrOutput) ToRecordPtrOutput() RecordPtrOutput

func (RecordPtrOutput) ToRecordPtrOutputWithContext added in v3.25.0 

func (o RecordPtrOutput) ToRecordPtrOutputWithContext(ctx context.Context) RecordPtrOutput

type RecordState 

type RecordState struct {
	// An alias block. Conflicts with `ttl` & `records`.
	// Alias record documented below.
	Aliases RecordAliasArrayInput
	// Allow creation of this record to overwrite an existing record, if any. This does not affect the ability to update the record using this provider and does not prevent other resources within this provider or manual Route 53 changes outside this provider from overwriting this record. `false` by default. This configuration is not recommended for most environments.
	AllowOverwrite pulumi.BoolPtrInput
	// A block indicating the routing behavior when associated health check fails. Conflicts with any other routing policy. Documented below.
	FailoverRoutingPolicies RecordFailoverRoutingPolicyArrayInput
	// [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) built using the zone domain and `name`.
	Fqdn pulumi.StringPtrInput
	// A block indicating a routing policy based on the geolocation of the requestor. Conflicts with any other routing policy. Documented below.
	GeolocationRoutingPolicies RecordGeolocationRoutingPolicyArrayInput
	// The health check the record should be associated with.
	HealthCheckId pulumi.StringPtrInput
	// A block indicating a routing policy based on the latency between the requestor and an AWS region. Conflicts with any other routing policy. Documented below.
	LatencyRoutingPolicies RecordLatencyRoutingPolicyArrayInput
	// Set to `true` to indicate a multivalue answer routing policy. Conflicts with any other routing policy.
	MultivalueAnswerRoutingPolicy pulumi.BoolPtrInput
	// DNS domain name for a CloudFront distribution, S3 bucket, ELB, or another resource record set in this hosted zone.
	Name pulumi.StringPtrInput
	// A string list of records. To specify a single record value longer than 255 characters such as a TXT record for DKIM, add `\"\"` inside the configuration string (e.g. `"first255characters\"\"morecharacters"`).
	Records pulumi.StringArrayInput
	// Unique identifier to differentiate records with routing policies from one another. Required if using `failover`, `geolocation`, `latency`, or `weighted` routing policies documented below.
	SetIdentifier pulumi.StringPtrInput
	// The TTL of the record.
	Ttl pulumi.IntPtrInput
	// `PRIMARY` or `SECONDARY`. A `PRIMARY` record will be served if its healthcheck is passing, otherwise the `SECONDARY` will be served. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-configuring-options.html#dns-failover-failover-rrsets
	Type pulumi.StringPtrInput
	// A block indicating a weighted routing policy. Conflicts with any other routing policy. Documented below.
	WeightedRoutingPolicies RecordWeightedRoutingPolicyArrayInput
	// Hosted zone ID for a CloudFront distribution, S3 bucket, ELB, or Route 53 hosted zone. See `resource_elb.zone_id` for example.
	ZoneId pulumi.StringPtrInput
}

func (RecordState) ElementType 

func (RecordState) ElementType() reflect.Type

type RecordType added in v3.18.0 

type RecordType pulumi.String

func (RecordType) ElementType added in v3.18.0 

func (RecordType) ElementType() reflect.Type

func (RecordType) ToStringOutput added in v3.18.0 

func (e RecordType) ToStringOutput() pulumi.StringOutput

func (RecordType) ToStringOutputWithContext added in v3.18.0 

func (e RecordType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RecordType) ToStringPtrOutput added in v3.18.0 

func (e RecordType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RecordType) ToStringPtrOutputWithContext added in v3.18.0 

func (e RecordType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RecordWeightedRoutingPolicy 

type RecordWeightedRoutingPolicy struct {
	// A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.
	Weight int `pulumi:"weight"`
}

type RecordWeightedRoutingPolicyArgs 

type RecordWeightedRoutingPolicyArgs struct {
	// A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.
	Weight pulumi.IntInput `pulumi:"weight"`
}

func (RecordWeightedRoutingPolicyArgs) ElementType 

func (RecordWeightedRoutingPolicyArgs) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutput 

func (i RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutputWithContext 

func (i RecordWeightedRoutingPolicyArgs) ToRecordWeightedRoutingPolicyOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyOutput

type RecordWeightedRoutingPolicyArray 

type RecordWeightedRoutingPolicyArray []RecordWeightedRoutingPolicyInput

func (RecordWeightedRoutingPolicyArray) ElementType 

func (RecordWeightedRoutingPolicyArray) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutput 

func (i RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput

func (RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutputWithContext 

func (i RecordWeightedRoutingPolicyArray) ToRecordWeightedRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyArrayOutput

type RecordWeightedRoutingPolicyArrayInput 

type RecordWeightedRoutingPolicyArrayInput interface {
	pulumi.Input

	ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput
	ToRecordWeightedRoutingPolicyArrayOutputWithContext(context.Context) RecordWeightedRoutingPolicyArrayOutput
}

RecordWeightedRoutingPolicyArrayInput is an input type that accepts RecordWeightedRoutingPolicyArray and RecordWeightedRoutingPolicyArrayOutput values. You can construct a concrete instance of `RecordWeightedRoutingPolicyArrayInput` via: 

RecordWeightedRoutingPolicyArray{ RecordWeightedRoutingPolicyArgs{...} }

type RecordWeightedRoutingPolicyArrayOutput 

type RecordWeightedRoutingPolicyArrayOutput struct{ *pulumi.OutputState }

func (RecordWeightedRoutingPolicyArrayOutput) ElementType 

func (RecordWeightedRoutingPolicyArrayOutput) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyArrayOutput) Index 

func (o RecordWeightedRoutingPolicyArrayOutput) Index(i pulumi.IntInput) RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutput 

func (o RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutput() RecordWeightedRoutingPolicyArrayOutput

func (RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutputWithContext 

func (o RecordWeightedRoutingPolicyArrayOutput) ToRecordWeightedRoutingPolicyArrayOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyArrayOutput

type RecordWeightedRoutingPolicyInput 

type RecordWeightedRoutingPolicyInput interface {
	pulumi.Input

	ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput
	ToRecordWeightedRoutingPolicyOutputWithContext(context.Context) RecordWeightedRoutingPolicyOutput
}

RecordWeightedRoutingPolicyInput is an input type that accepts RecordWeightedRoutingPolicyArgs and RecordWeightedRoutingPolicyOutput values. You can construct a concrete instance of `RecordWeightedRoutingPolicyInput` via: 

RecordWeightedRoutingPolicyArgs{...}

type RecordWeightedRoutingPolicyOutput 

type RecordWeightedRoutingPolicyOutput struct{ *pulumi.OutputState }

func (RecordWeightedRoutingPolicyOutput) ElementType 

func (RecordWeightedRoutingPolicyOutput) ElementType() reflect.Type

func (RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutput 

func (o RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutput() RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutputWithContext 

func (o RecordWeightedRoutingPolicyOutput) ToRecordWeightedRoutingPolicyOutputWithContext(ctx context.Context) RecordWeightedRoutingPolicyOutput

func (RecordWeightedRoutingPolicyOutput) Weight 

func (o RecordWeightedRoutingPolicyOutput) Weight() pulumi.IntOutput

A numeric value indicating the relative weight of the record. See http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html#routing-policy-weighted.

type ResolverDnsSecConfig added in v3.24.0 

type ResolverDnsSecConfig struct {
	pulumi.CustomResourceState

	// The ARN for a configuration for DNSSEC validation.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The owner account ID of the virtual private cloud (VPC) for a configuration for DNSSEC validation.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// The ID of the virtual private cloud (VPC) that you're updating the DNSSEC validation status for.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
	// The validation status for a DNSSEC configuration. The status can be one of the following: `ENABLING`, `ENABLED`, `DISABLING` and `DISABLED`.
	ValidationStatus pulumi.StringOutput `pulumi:"validationStatus"`
}

Provides a Route 53 Resolver DNSSEC config resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleVpc, err := ec2.NewVpc(ctx, "exampleVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.0.0.0/16"),
			EnableDnsSupport:   pulumi.Bool(true),
			EnableDnsHostnames: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewResolverDnsSecConfig(ctx, "exampleResolverDnsSecConfig", &route53.ResolverDnsSecConfigArgs{
			ResourceId: exampleVpc.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver DNSSEC configs can be imported using the Route 53 Resolver DNSSEC config ID, e.g.

```sh 

$ pulumi import aws:route53/resolverDnsSecConfig:ResolverDnsSecConfig example rdsc-be1866ecc1683e95

```

func GetResolverDnsSecConfig added in v3.24.0 

func GetResolverDnsSecConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverDnsSecConfigState, opts ...pulumi.ResourceOption) (*ResolverDnsSecConfig, error)

GetResolverDnsSecConfig gets an existing ResolverDnsSecConfig resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverDnsSecConfig added in v3.24.0 

func NewResolverDnsSecConfig(ctx *pulumi.Context,
	name string, args *ResolverDnsSecConfigArgs, opts ...pulumi.ResourceOption) (*ResolverDnsSecConfig, error)

NewResolverDnsSecConfig registers a new resource with the given unique name, arguments, and options.

func (*ResolverDnsSecConfig) ElementType added in v3.24.0 

func (*ResolverDnsSecConfig) ElementType() reflect.Type

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigOutput added in v3.24.0 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigOutput() ResolverDnsSecConfigOutput

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigOutputWithContext added in v3.24.0 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigOutputWithContext(ctx context.Context) ResolverDnsSecConfigOutput

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutput added in v3.25.0 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutputWithContext added in v3.25.0 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutputWithContext(ctx context.Context) ResolverDnsSecConfigPtrOutput

type ResolverDnsSecConfigArgs added in v3.24.0 

type ResolverDnsSecConfigArgs struct {
	// The ID of the virtual private cloud (VPC) that you're updating the DNSSEC validation status for.
	ResourceId pulumi.StringInput
}

The set of arguments for constructing a ResolverDnsSecConfig resource.

func (ResolverDnsSecConfigArgs) ElementType added in v3.24.0 

func (ResolverDnsSecConfigArgs) ElementType() reflect.Type

type ResolverDnsSecConfigArray added in v3.25.0 

type ResolverDnsSecConfigArray []ResolverDnsSecConfigInput

func (ResolverDnsSecConfigArray) ElementType added in v3.25.0 

func (ResolverDnsSecConfigArray) ElementType() reflect.Type

func (ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutput added in v3.25.0 

func (i ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutput() ResolverDnsSecConfigArrayOutput

func (ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutputWithContext added in v3.25.0 

func (i ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutputWithContext(ctx context.Context) ResolverDnsSecConfigArrayOutput

type ResolverDnsSecConfigArrayInput added in v3.25.0 

type ResolverDnsSecConfigArrayInput interface {
	pulumi.Input

	ToResolverDnsSecConfigArrayOutput() ResolverDnsSecConfigArrayOutput
	ToResolverDnsSecConfigArrayOutputWithContext(context.Context) ResolverDnsSecConfigArrayOutput
}

ResolverDnsSecConfigArrayInput is an input type that accepts ResolverDnsSecConfigArray and ResolverDnsSecConfigArrayOutput values. You can construct a concrete instance of `ResolverDnsSecConfigArrayInput` via: 

ResolverDnsSecConfigArray{ ResolverDnsSecConfigArgs{...} }

type ResolverDnsSecConfigArrayOutput added in v3.25.0 

type ResolverDnsSecConfigArrayOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigArrayOutput) ElementType added in v3.25.0 

func (ResolverDnsSecConfigArrayOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigArrayOutput) Index added in v3.25.0 

func (o ResolverDnsSecConfigArrayOutput) Index(i pulumi.IntInput) ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutput added in v3.25.0 

func (o ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutput() ResolverDnsSecConfigArrayOutput

func (ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutputWithContext added in v3.25.0 

func (o ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutputWithContext(ctx context.Context) ResolverDnsSecConfigArrayOutput

type ResolverDnsSecConfigInput added in v3.24.0 

type ResolverDnsSecConfigInput interface {
	pulumi.Input

	ToResolverDnsSecConfigOutput() ResolverDnsSecConfigOutput
	ToResolverDnsSecConfigOutputWithContext(ctx context.Context) ResolverDnsSecConfigOutput
}

type ResolverDnsSecConfigMap added in v3.25.0 

type ResolverDnsSecConfigMap map[string]ResolverDnsSecConfigInput

func (ResolverDnsSecConfigMap) ElementType added in v3.25.0 

func (ResolverDnsSecConfigMap) ElementType() reflect.Type

func (ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutput added in v3.25.0 

func (i ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutput() ResolverDnsSecConfigMapOutput

func (ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutputWithContext added in v3.25.0 

func (i ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutputWithContext(ctx context.Context) ResolverDnsSecConfigMapOutput

type ResolverDnsSecConfigMapInput added in v3.25.0 

type ResolverDnsSecConfigMapInput interface {
	pulumi.Input

	ToResolverDnsSecConfigMapOutput() ResolverDnsSecConfigMapOutput
	ToResolverDnsSecConfigMapOutputWithContext(context.Context) ResolverDnsSecConfigMapOutput
}

ResolverDnsSecConfigMapInput is an input type that accepts ResolverDnsSecConfigMap and ResolverDnsSecConfigMapOutput values. You can construct a concrete instance of `ResolverDnsSecConfigMapInput` via: 

ResolverDnsSecConfigMap{ "key": ResolverDnsSecConfigArgs{...} }

type ResolverDnsSecConfigMapOutput added in v3.25.0 

type ResolverDnsSecConfigMapOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigMapOutput) ElementType added in v3.25.0 

func (ResolverDnsSecConfigMapOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigMapOutput) MapIndex added in v3.25.0 

func (o ResolverDnsSecConfigMapOutput) MapIndex(k pulumi.StringInput) ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutput added in v3.25.0 

func (o ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutput() ResolverDnsSecConfigMapOutput

func (ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutputWithContext added in v3.25.0 

func (o ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutputWithContext(ctx context.Context) ResolverDnsSecConfigMapOutput

type ResolverDnsSecConfigOutput added in v3.24.0 

type ResolverDnsSecConfigOutput struct {
	*pulumi.OutputState
}

func (ResolverDnsSecConfigOutput) ElementType added in v3.24.0 

func (ResolverDnsSecConfigOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutput added in v3.24.0 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutput() ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutputWithContext added in v3.24.0 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutputWithContext(ctx context.Context) ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutput added in v3.25.0 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutputWithContext added in v3.25.0 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutputWithContext(ctx context.Context) ResolverDnsSecConfigPtrOutput

type ResolverDnsSecConfigPtrInput added in v3.25.0 

type ResolverDnsSecConfigPtrInput interface {
	pulumi.Input

	ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput
	ToResolverDnsSecConfigPtrOutputWithContext(ctx context.Context) ResolverDnsSecConfigPtrOutput
}

type ResolverDnsSecConfigPtrOutput added in v3.25.0 

type ResolverDnsSecConfigPtrOutput struct {
	*pulumi.OutputState
}

func (ResolverDnsSecConfigPtrOutput) ElementType added in v3.25.0 

func (ResolverDnsSecConfigPtrOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutput added in v3.25.0 

func (o ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutputWithContext added in v3.25.0 

func (o ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutputWithContext(ctx context.Context) ResolverDnsSecConfigPtrOutput

type ResolverDnsSecConfigState added in v3.24.0 

type ResolverDnsSecConfigState struct {
	// The ARN for a configuration for DNSSEC validation.
	Arn pulumi.StringPtrInput
	// The owner account ID of the virtual private cloud (VPC) for a configuration for DNSSEC validation.
	OwnerId pulumi.StringPtrInput
	// The ID of the virtual private cloud (VPC) that you're updating the DNSSEC validation status for.
	ResourceId pulumi.StringPtrInput
	// The validation status for a DNSSEC configuration. The status can be one of the following: `ENABLING`, `ENABLED`, `DISABLING` and `DISABLED`.
	ValidationStatus pulumi.StringPtrInput
}

func (ResolverDnsSecConfigState) ElementType added in v3.24.0 

func (ResolverDnsSecConfigState) ElementType() reflect.Type

type ResolverEndpoint 

type ResolverEndpoint struct {
	pulumi.CustomResourceState

	// The ARN of the Route 53 Resolver endpoint.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringOutput `pulumi:"direction"`
	// The ID of the VPC that you want to create the resolver endpoint in.
	HostVpcId pulumi.StringOutput `pulumi:"hostVpcId"`
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayOutput `pulumi:"ipAddresses"`
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayOutput `pulumi:"securityGroupIds"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a Route 53 Resolver endpoint resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverEndpoint(ctx, "foo", &route53.ResolverEndpointArgs{
			Direction: pulumi.String("INBOUND"),
			SecurityGroupIds: pulumi.StringArray{
				pulumi.Any(aws_security_group.Sg1.Id),
				pulumi.Any(aws_security_group.Sg2.Id),
			},
			IpAddresses: route53.ResolverEndpointIpAddressArray{
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(aws_subnet.Sn1.Id),
				},
				&route53.ResolverEndpointIpAddressArgs{
					SubnetId: pulumi.Any(aws_subnet.Sn2.Id),
					Ip:       pulumi.String("10.0.64.4"),
				},
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver endpoints can be imported using the Route 53 Resolver endpoint ID, e.g.

```sh 

$ pulumi import aws:route53/resolverEndpoint:ResolverEndpoint foo rslvr-in-abcdef01234567890

```

func GetResolverEndpoint 

func GetResolverEndpoint(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverEndpointState, opts ...pulumi.ResourceOption) (*ResolverEndpoint, error)

GetResolverEndpoint gets an existing ResolverEndpoint resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverEndpoint 

func NewResolverEndpoint(ctx *pulumi.Context,
	name string, args *ResolverEndpointArgs, opts ...pulumi.ResourceOption) (*ResolverEndpoint, error)

NewResolverEndpoint registers a new resource with the given unique name, arguments, and options.

func (*ResolverEndpoint) ElementType added in v3.13.0 

func (*ResolverEndpoint) ElementType() reflect.Type

func (*ResolverEndpoint) ToResolverEndpointOutput added in v3.13.0 

func (i *ResolverEndpoint) ToResolverEndpointOutput() ResolverEndpointOutput

func (*ResolverEndpoint) ToResolverEndpointOutputWithContext added in v3.13.0 

func (i *ResolverEndpoint) ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput

func (*ResolverEndpoint) ToResolverEndpointPtrOutput added in v3.25.0 

func (i *ResolverEndpoint) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (*ResolverEndpoint) ToResolverEndpointPtrOutputWithContext added in v3.25.0 

func (i *ResolverEndpoint) ToResolverEndpointPtrOutputWithContext(ctx context.Context) ResolverEndpointPtrOutput

type ResolverEndpointArgs 

type ResolverEndpointArgs struct {
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringInput
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayInput
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringPtrInput
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverEndpoint resource.

func (ResolverEndpointArgs) ElementType 

func (ResolverEndpointArgs) ElementType() reflect.Type

type ResolverEndpointArray added in v3.25.0 

type ResolverEndpointArray []ResolverEndpointInput

func (ResolverEndpointArray) ElementType added in v3.25.0 

func (ResolverEndpointArray) ElementType() reflect.Type

func (ResolverEndpointArray) ToResolverEndpointArrayOutput added in v3.25.0 

func (i ResolverEndpointArray) ToResolverEndpointArrayOutput() ResolverEndpointArrayOutput

func (ResolverEndpointArray) ToResolverEndpointArrayOutputWithContext added in v3.25.0 

func (i ResolverEndpointArray) ToResolverEndpointArrayOutputWithContext(ctx context.Context) ResolverEndpointArrayOutput

type ResolverEndpointArrayInput added in v3.25.0 

type ResolverEndpointArrayInput interface {
	pulumi.Input

	ToResolverEndpointArrayOutput() ResolverEndpointArrayOutput
	ToResolverEndpointArrayOutputWithContext(context.Context) ResolverEndpointArrayOutput
}

ResolverEndpointArrayInput is an input type that accepts ResolverEndpointArray and ResolverEndpointArrayOutput values. You can construct a concrete instance of `ResolverEndpointArrayInput` via: 

ResolverEndpointArray{ ResolverEndpointArgs{...} }

type ResolverEndpointArrayOutput added in v3.25.0 

type ResolverEndpointArrayOutput struct{ *pulumi.OutputState }

func (ResolverEndpointArrayOutput) ElementType added in v3.25.0 

func (ResolverEndpointArrayOutput) ElementType() reflect.Type

func (ResolverEndpointArrayOutput) Index added in v3.25.0 

func (o ResolverEndpointArrayOutput) Index(i pulumi.IntInput) ResolverEndpointOutput

func (ResolverEndpointArrayOutput) ToResolverEndpointArrayOutput added in v3.25.0 

func (o ResolverEndpointArrayOutput) ToResolverEndpointArrayOutput() ResolverEndpointArrayOutput

func (ResolverEndpointArrayOutput) ToResolverEndpointArrayOutputWithContext added in v3.25.0 

func (o ResolverEndpointArrayOutput) ToResolverEndpointArrayOutputWithContext(ctx context.Context) ResolverEndpointArrayOutput

type ResolverEndpointInput added in v3.13.0 

type ResolverEndpointInput interface {
	pulumi.Input

	ToResolverEndpointOutput() ResolverEndpointOutput
	ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput
}

type ResolverEndpointIpAddress 

type ResolverEndpointIpAddress struct {
	// The IP address in the subnet that you want to use for DNS queries.
	Ip   *string `pulumi:"ip"`
	IpId *string `pulumi:"ipId"`
	// The ID of the subnet that contains the IP address.
	SubnetId string `pulumi:"subnetId"`
}

type ResolverEndpointIpAddressArgs 

type ResolverEndpointIpAddressArgs struct {
	// The IP address in the subnet that you want to use for DNS queries.
	Ip   pulumi.StringPtrInput `pulumi:"ip"`
	IpId pulumi.StringPtrInput `pulumi:"ipId"`
	// The ID of the subnet that contains the IP address.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (ResolverEndpointIpAddressArgs) ElementType 

func (ResolverEndpointIpAddressArgs) ElementType() reflect.Type

func (ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutput 

func (i ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutputWithContext 

func (i ResolverEndpointIpAddressArgs) ToResolverEndpointIpAddressOutputWithContext(ctx context.Context) ResolverEndpointIpAddressOutput

type ResolverEndpointIpAddressArray 

type ResolverEndpointIpAddressArray []ResolverEndpointIpAddressInput

func (ResolverEndpointIpAddressArray) ElementType 

func (ResolverEndpointIpAddressArray) ElementType() reflect.Type

func (ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutput 

func (i ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput

func (ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutputWithContext 

func (i ResolverEndpointIpAddressArray) ToResolverEndpointIpAddressArrayOutputWithContext(ctx context.Context) ResolverEndpointIpAddressArrayOutput

type ResolverEndpointIpAddressArrayInput 

type ResolverEndpointIpAddressArrayInput interface {
	pulumi.Input

	ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput
	ToResolverEndpointIpAddressArrayOutputWithContext(context.Context) ResolverEndpointIpAddressArrayOutput
}

ResolverEndpointIpAddressArrayInput is an input type that accepts ResolverEndpointIpAddressArray and ResolverEndpointIpAddressArrayOutput values. You can construct a concrete instance of `ResolverEndpointIpAddressArrayInput` via: 

ResolverEndpointIpAddressArray{ ResolverEndpointIpAddressArgs{...} }

type ResolverEndpointIpAddressArrayOutput 

type ResolverEndpointIpAddressArrayOutput struct{ *pulumi.OutputState }

func (ResolverEndpointIpAddressArrayOutput) ElementType 

func (ResolverEndpointIpAddressArrayOutput) ElementType() reflect.Type

func (ResolverEndpointIpAddressArrayOutput) Index 

func (o ResolverEndpointIpAddressArrayOutput) Index(i pulumi.IntInput) ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutput 

func (o ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutput() ResolverEndpointIpAddressArrayOutput

func (ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutputWithContext 

func (o ResolverEndpointIpAddressArrayOutput) ToResolverEndpointIpAddressArrayOutputWithContext(ctx context.Context) ResolverEndpointIpAddressArrayOutput

type ResolverEndpointIpAddressInput 

type ResolverEndpointIpAddressInput interface {
	pulumi.Input

	ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput
	ToResolverEndpointIpAddressOutputWithContext(context.Context) ResolverEndpointIpAddressOutput
}

ResolverEndpointIpAddressInput is an input type that accepts ResolverEndpointIpAddressArgs and ResolverEndpointIpAddressOutput values. You can construct a concrete instance of `ResolverEndpointIpAddressInput` via: 

ResolverEndpointIpAddressArgs{...}

type ResolverEndpointIpAddressOutput 

type ResolverEndpointIpAddressOutput struct{ *pulumi.OutputState }

func (ResolverEndpointIpAddressOutput) ElementType 

func (ResolverEndpointIpAddressOutput) ElementType() reflect.Type

func (ResolverEndpointIpAddressOutput) Ip 

func (o ResolverEndpointIpAddressOutput) Ip() pulumi.StringPtrOutput

The IP address in the subnet that you want to use for DNS queries.

func (ResolverEndpointIpAddressOutput) IpId 

func (o ResolverEndpointIpAddressOutput) IpId() pulumi.StringPtrOutput

func (ResolverEndpointIpAddressOutput) SubnetId 

func (o ResolverEndpointIpAddressOutput) SubnetId() pulumi.StringOutput

The ID of the subnet that contains the IP address.

func (ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutput 

func (o ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutput() ResolverEndpointIpAddressOutput

func (ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutputWithContext 

func (o ResolverEndpointIpAddressOutput) ToResolverEndpointIpAddressOutputWithContext(ctx context.Context) ResolverEndpointIpAddressOutput

type ResolverEndpointMap added in v3.25.0 

type ResolverEndpointMap map[string]ResolverEndpointInput

func (ResolverEndpointMap) ElementType added in v3.25.0 

func (ResolverEndpointMap) ElementType() reflect.Type

func (ResolverEndpointMap) ToResolverEndpointMapOutput added in v3.25.0 

func (i ResolverEndpointMap) ToResolverEndpointMapOutput() ResolverEndpointMapOutput

func (ResolverEndpointMap) ToResolverEndpointMapOutputWithContext added in v3.25.0 

func (i ResolverEndpointMap) ToResolverEndpointMapOutputWithContext(ctx context.Context) ResolverEndpointMapOutput

type ResolverEndpointMapInput added in v3.25.0 

type ResolverEndpointMapInput interface {
	pulumi.Input

	ToResolverEndpointMapOutput() ResolverEndpointMapOutput
	ToResolverEndpointMapOutputWithContext(context.Context) ResolverEndpointMapOutput
}

ResolverEndpointMapInput is an input type that accepts ResolverEndpointMap and ResolverEndpointMapOutput values. You can construct a concrete instance of `ResolverEndpointMapInput` via: 

ResolverEndpointMap{ "key": ResolverEndpointArgs{...} }

type ResolverEndpointMapOutput added in v3.25.0 

type ResolverEndpointMapOutput struct{ *pulumi.OutputState }

func (ResolverEndpointMapOutput) ElementType added in v3.25.0 

func (ResolverEndpointMapOutput) ElementType() reflect.Type

func (ResolverEndpointMapOutput) MapIndex added in v3.25.0 

func (o ResolverEndpointMapOutput) MapIndex(k pulumi.StringInput) ResolverEndpointOutput

func (ResolverEndpointMapOutput) ToResolverEndpointMapOutput added in v3.25.0 

func (o ResolverEndpointMapOutput) ToResolverEndpointMapOutput() ResolverEndpointMapOutput

func (ResolverEndpointMapOutput) ToResolverEndpointMapOutputWithContext added in v3.25.0 

func (o ResolverEndpointMapOutput) ToResolverEndpointMapOutputWithContext(ctx context.Context) ResolverEndpointMapOutput

type ResolverEndpointOutput added in v3.13.0 

type ResolverEndpointOutput struct {
	*pulumi.OutputState
}

func (ResolverEndpointOutput) ElementType added in v3.13.0 

func (ResolverEndpointOutput) ElementType() reflect.Type

func (ResolverEndpointOutput) ToResolverEndpointOutput added in v3.13.0 

func (o ResolverEndpointOutput) ToResolverEndpointOutput() ResolverEndpointOutput

func (ResolverEndpointOutput) ToResolverEndpointOutputWithContext added in v3.13.0 

func (o ResolverEndpointOutput) ToResolverEndpointOutputWithContext(ctx context.Context) ResolverEndpointOutput

func (ResolverEndpointOutput) ToResolverEndpointPtrOutput added in v3.25.0 

func (o ResolverEndpointOutput) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (ResolverEndpointOutput) ToResolverEndpointPtrOutputWithContext added in v3.25.0 

func (o ResolverEndpointOutput) ToResolverEndpointPtrOutputWithContext(ctx context.Context) ResolverEndpointPtrOutput

type ResolverEndpointPtrInput added in v3.25.0 

type ResolverEndpointPtrInput interface {
	pulumi.Input

	ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput
	ToResolverEndpointPtrOutputWithContext(ctx context.Context) ResolverEndpointPtrOutput
}

type ResolverEndpointPtrOutput added in v3.25.0 

type ResolverEndpointPtrOutput struct {
	*pulumi.OutputState
}

func (ResolverEndpointPtrOutput) ElementType added in v3.25.0 

func (ResolverEndpointPtrOutput) ElementType() reflect.Type

func (ResolverEndpointPtrOutput) ToResolverEndpointPtrOutput added in v3.25.0 

func (o ResolverEndpointPtrOutput) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (ResolverEndpointPtrOutput) ToResolverEndpointPtrOutputWithContext added in v3.25.0 

func (o ResolverEndpointPtrOutput) ToResolverEndpointPtrOutputWithContext(ctx context.Context) ResolverEndpointPtrOutput

type ResolverEndpointState 

type ResolverEndpointState struct {
	// The ARN of the Route 53 Resolver endpoint.
	Arn pulumi.StringPtrInput
	// The direction of DNS queries to or from the Route 53 Resolver endpoint.
	// Valid values are `INBOUND` (resolver forwards DNS queries to the DNS service for a VPC from your network or another VPC)
	// or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to your network or another VPC).
	Direction pulumi.StringPtrInput
	// The ID of the VPC that you want to create the resolver endpoint in.
	HostVpcId pulumi.StringPtrInput
	// The subnets and IP addresses in your VPC that you want DNS queries to pass through on the way from your VPCs
	// to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
	IpAddresses ResolverEndpointIpAddressArrayInput
	// The friendly name of the Route 53 Resolver endpoint.
	Name pulumi.StringPtrInput
	// The ID of one or more security groups that you want to use to control access to this VPC.
	SecurityGroupIds pulumi.StringArrayInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (ResolverEndpointState) ElementType 

func (ResolverEndpointState) ElementType() reflect.Type

type ResolverQueryLogConfig added in v3.5.0 

type ResolverQueryLogConfig struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) of the Route 53 Resolver query logging configuration.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringOutput `pulumi:"destinationArn"`
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringOutput `pulumi:"name"`
	// The AWS account ID of the account that created the query logging configuration.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// An indication of whether the query logging configuration is shared with other AWS accounts, or was shared with the current account by another AWS account.
	// Sharing is configured through AWS Resource Access Manager (AWS RAM).
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringOutput `pulumi:"shareStatus"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a Route 53 Resolver query logging configuration resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverQueryLogConfig(ctx, "example", &route53.ResolverQueryLogConfigArgs{
			DestinationArn: pulumi.Any(aws_s3_bucket.Example.Arn),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver query logging configurations can be imported using the Route 53 Resolver query logging configuration ID, e.g.

```sh 

$ pulumi import aws:route53/resolverQueryLogConfig:ResolverQueryLogConfig example rqlc-92edc3b1838248bf

```

func GetResolverQueryLogConfig added in v3.5.0 

func GetResolverQueryLogConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverQueryLogConfigState, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfig, error)

GetResolverQueryLogConfig gets an existing ResolverQueryLogConfig resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverQueryLogConfig added in v3.5.0 

func NewResolverQueryLogConfig(ctx *pulumi.Context,
	name string, args *ResolverQueryLogConfigArgs, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfig, error)

NewResolverQueryLogConfig registers a new resource with the given unique name, arguments, and options.

func (*ResolverQueryLogConfig) ElementType added in v3.13.0 

func (*ResolverQueryLogConfig) ElementType() reflect.Type

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigOutput added in v3.13.0 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigOutputWithContext added in v3.13.0 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutput added in v3.25.0 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutputWithContext added in v3.25.0 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigPtrOutput

type ResolverQueryLogConfigArgs added in v3.5.0 

type ResolverQueryLogConfigArgs struct {
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringInput
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverQueryLogConfig resource.

func (ResolverQueryLogConfigArgs) ElementType added in v3.5.0 

func (ResolverQueryLogConfigArgs) ElementType() reflect.Type

type ResolverQueryLogConfigArray added in v3.25.0 

type ResolverQueryLogConfigArray []ResolverQueryLogConfigInput

func (ResolverQueryLogConfigArray) ElementType added in v3.25.0 

func (ResolverQueryLogConfigArray) ElementType() reflect.Type

func (ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutput added in v3.25.0 

func (i ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutput() ResolverQueryLogConfigArrayOutput

func (ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutputWithContext added in v3.25.0 

func (i ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutputWithContext(ctx context.Context) ResolverQueryLogConfigArrayOutput

type ResolverQueryLogConfigArrayInput added in v3.25.0 

type ResolverQueryLogConfigArrayInput interface {
	pulumi.Input

	ToResolverQueryLogConfigArrayOutput() ResolverQueryLogConfigArrayOutput
	ToResolverQueryLogConfigArrayOutputWithContext(context.Context) ResolverQueryLogConfigArrayOutput
}

ResolverQueryLogConfigArrayInput is an input type that accepts ResolverQueryLogConfigArray and ResolverQueryLogConfigArrayOutput values. You can construct a concrete instance of `ResolverQueryLogConfigArrayInput` via: 

ResolverQueryLogConfigArray{ ResolverQueryLogConfigArgs{...} }

type ResolverQueryLogConfigArrayOutput added in v3.25.0 

type ResolverQueryLogConfigArrayOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigArrayOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigArrayOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigArrayOutput) Index added in v3.25.0 

func (o ResolverQueryLogConfigArrayOutput) Index(i pulumi.IntInput) ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutput added in v3.25.0 

func (o ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutput() ResolverQueryLogConfigArrayOutput

func (ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutputWithContext(ctx context.Context) ResolverQueryLogConfigArrayOutput

type ResolverQueryLogConfigAssociation added in v3.5.0 

type ResolverQueryLogConfigAssociation struct {
	pulumi.CustomResourceState

	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringOutput `pulumi:"resolverQueryLogConfigId"`
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
}

Provides a Route 53 Resolver query logging configuration association resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverQueryLogConfigAssociation(ctx, "example", &route53.ResolverQueryLogConfigAssociationArgs{
			ResolverQueryLogConfigId: pulumi.Any(aws_route53_resolver_query_log_config.Example.Id),
			ResourceId:               pulumi.Any(aws_vpc.Example.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver query logging configuration associations can be imported using the Route 53 Resolver query logging configuration association ID, e.g.

```sh 

$ pulumi import aws:route53/resolverQueryLogConfigAssociation:ResolverQueryLogConfigAssociation example rqlca-b320624fef3c4d70

```

func GetResolverQueryLogConfigAssociation added in v3.5.0 

func GetResolverQueryLogConfigAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverQueryLogConfigAssociationState, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfigAssociation, error)

GetResolverQueryLogConfigAssociation gets an existing ResolverQueryLogConfigAssociation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverQueryLogConfigAssociation added in v3.5.0 

func NewResolverQueryLogConfigAssociation(ctx *pulumi.Context,
	name string, args *ResolverQueryLogConfigAssociationArgs, opts ...pulumi.ResourceOption) (*ResolverQueryLogConfigAssociation, error)

NewResolverQueryLogConfigAssociation registers a new resource with the given unique name, arguments, and options.

func (*ResolverQueryLogConfigAssociation) ElementType added in v3.13.0 

func (*ResolverQueryLogConfigAssociation) ElementType() reflect.Type

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput added in v3.13.0 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutputWithContext added in v3.13.0 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutput added in v3.25.0 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutputWithContext added in v3.25.0 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationPtrOutput

type ResolverQueryLogConfigAssociationArgs added in v3.5.0 

type ResolverQueryLogConfigAssociationArgs struct {
	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringInput
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringInput
}

The set of arguments for constructing a ResolverQueryLogConfigAssociation resource.

func (ResolverQueryLogConfigAssociationArgs) ElementType added in v3.5.0 

func (ResolverQueryLogConfigAssociationArgs) ElementType() reflect.Type

type ResolverQueryLogConfigAssociationArray added in v3.25.0 

type ResolverQueryLogConfigAssociationArray []ResolverQueryLogConfigAssociationInput

func (ResolverQueryLogConfigAssociationArray) ElementType added in v3.25.0 

func (ResolverQueryLogConfigAssociationArray) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutput added in v3.25.0 

func (i ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutput() ResolverQueryLogConfigAssociationArrayOutput

func (ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutputWithContext added in v3.25.0 

func (i ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationArrayOutput

type ResolverQueryLogConfigAssociationArrayInput added in v3.25.0 

type ResolverQueryLogConfigAssociationArrayInput interface {
	pulumi.Input

	ToResolverQueryLogConfigAssociationArrayOutput() ResolverQueryLogConfigAssociationArrayOutput
	ToResolverQueryLogConfigAssociationArrayOutputWithContext(context.Context) ResolverQueryLogConfigAssociationArrayOutput
}

ResolverQueryLogConfigAssociationArrayInput is an input type that accepts ResolverQueryLogConfigAssociationArray and ResolverQueryLogConfigAssociationArrayOutput values. You can construct a concrete instance of `ResolverQueryLogConfigAssociationArrayInput` via: 

ResolverQueryLogConfigAssociationArray{ ResolverQueryLogConfigAssociationArgs{...} }

type ResolverQueryLogConfigAssociationArrayOutput added in v3.25.0 

type ResolverQueryLogConfigAssociationArrayOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationArrayOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigAssociationArrayOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationArrayOutput) Index added in v3.25.0 

func (o ResolverQueryLogConfigAssociationArrayOutput) Index(i pulumi.IntInput) ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutput added in v3.25.0 

func (o ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutput() ResolverQueryLogConfigAssociationArrayOutput

func (ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationArrayOutput

type ResolverQueryLogConfigAssociationInput added in v3.13.0 

type ResolverQueryLogConfigAssociationInput interface {
	pulumi.Input

	ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput
	ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput
}

type ResolverQueryLogConfigAssociationMap added in v3.25.0 

type ResolverQueryLogConfigAssociationMap map[string]ResolverQueryLogConfigAssociationInput

func (ResolverQueryLogConfigAssociationMap) ElementType added in v3.25.0 

func (ResolverQueryLogConfigAssociationMap) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutput added in v3.25.0 

func (i ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutput() ResolverQueryLogConfigAssociationMapOutput

func (ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutputWithContext added in v3.25.0 

func (i ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationMapOutput

type ResolverQueryLogConfigAssociationMapInput added in v3.25.0 

type ResolverQueryLogConfigAssociationMapInput interface {
	pulumi.Input

	ToResolverQueryLogConfigAssociationMapOutput() ResolverQueryLogConfigAssociationMapOutput
	ToResolverQueryLogConfigAssociationMapOutputWithContext(context.Context) ResolverQueryLogConfigAssociationMapOutput
}

ResolverQueryLogConfigAssociationMapInput is an input type that accepts ResolverQueryLogConfigAssociationMap and ResolverQueryLogConfigAssociationMapOutput values. You can construct a concrete instance of `ResolverQueryLogConfigAssociationMapInput` via: 

ResolverQueryLogConfigAssociationMap{ "key": ResolverQueryLogConfigAssociationArgs{...} }

type ResolverQueryLogConfigAssociationMapOutput added in v3.25.0 

type ResolverQueryLogConfigAssociationMapOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationMapOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigAssociationMapOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationMapOutput) MapIndex added in v3.25.0 

func (o ResolverQueryLogConfigAssociationMapOutput) MapIndex(k pulumi.StringInput) ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutput added in v3.25.0 

func (o ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutput() ResolverQueryLogConfigAssociationMapOutput

func (ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationMapOutput

type ResolverQueryLogConfigAssociationOutput added in v3.13.0 

type ResolverQueryLogConfigAssociationOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigAssociationOutput) ElementType added in v3.13.0 

func (ResolverQueryLogConfigAssociationOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput added in v3.13.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutputWithContext added in v3.13.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutput added in v3.25.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationPtrOutput

type ResolverQueryLogConfigAssociationPtrInput added in v3.25.0 

type ResolverQueryLogConfigAssociationPtrInput interface {
	pulumi.Input

	ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput
	ToResolverQueryLogConfigAssociationPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationPtrOutput
}

type ResolverQueryLogConfigAssociationPtrOutput added in v3.25.0 

type ResolverQueryLogConfigAssociationPtrOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigAssociationPtrOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigAssociationPtrOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutput added in v3.25.0 

func (o ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigAssociationPtrOutput

type ResolverQueryLogConfigAssociationState added in v3.5.0 

type ResolverQueryLogConfigAssociationState struct {
	// The ID of the Route 53 Resolver query logging configuration that you want to associate a VPC with.
	ResolverQueryLogConfigId pulumi.StringPtrInput
	// The ID of a VPC that you want this query logging configuration to log queries for.
	ResourceId pulumi.StringPtrInput
}

func (ResolverQueryLogConfigAssociationState) ElementType added in v3.5.0 

func (ResolverQueryLogConfigAssociationState) ElementType() reflect.Type

type ResolverQueryLogConfigInput added in v3.13.0 

type ResolverQueryLogConfigInput interface {
	pulumi.Input

	ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput
	ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput
}

type ResolverQueryLogConfigMap added in v3.25.0 

type ResolverQueryLogConfigMap map[string]ResolverQueryLogConfigInput

func (ResolverQueryLogConfigMap) ElementType added in v3.25.0 

func (ResolverQueryLogConfigMap) ElementType() reflect.Type

func (ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutput added in v3.25.0 

func (i ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutput() ResolverQueryLogConfigMapOutput

func (ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutputWithContext added in v3.25.0 

func (i ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutputWithContext(ctx context.Context) ResolverQueryLogConfigMapOutput

type ResolverQueryLogConfigMapInput added in v3.25.0 

type ResolverQueryLogConfigMapInput interface {
	pulumi.Input

	ToResolverQueryLogConfigMapOutput() ResolverQueryLogConfigMapOutput
	ToResolverQueryLogConfigMapOutputWithContext(context.Context) ResolverQueryLogConfigMapOutput
}

ResolverQueryLogConfigMapInput is an input type that accepts ResolverQueryLogConfigMap and ResolverQueryLogConfigMapOutput values. You can construct a concrete instance of `ResolverQueryLogConfigMapInput` via: 

ResolverQueryLogConfigMap{ "key": ResolverQueryLogConfigArgs{...} }

type ResolverQueryLogConfigMapOutput added in v3.25.0 

type ResolverQueryLogConfigMapOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigMapOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigMapOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigMapOutput) MapIndex added in v3.25.0 

func (o ResolverQueryLogConfigMapOutput) MapIndex(k pulumi.StringInput) ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutput added in v3.25.0 

func (o ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutput() ResolverQueryLogConfigMapOutput

func (ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutputWithContext(ctx context.Context) ResolverQueryLogConfigMapOutput

type ResolverQueryLogConfigOutput added in v3.13.0 

type ResolverQueryLogConfigOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigOutput) ElementType added in v3.13.0 

func (ResolverQueryLogConfigOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput added in v3.13.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutputWithContext added in v3.13.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutputWithContext(ctx context.Context) ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutput added in v3.25.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigPtrOutput

type ResolverQueryLogConfigPtrInput added in v3.25.0 

type ResolverQueryLogConfigPtrInput interface {
	pulumi.Input

	ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput
	ToResolverQueryLogConfigPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigPtrOutput
}

type ResolverQueryLogConfigPtrOutput added in v3.25.0 

type ResolverQueryLogConfigPtrOutput struct {
	*pulumi.OutputState
}

func (ResolverQueryLogConfigPtrOutput) ElementType added in v3.25.0 

func (ResolverQueryLogConfigPtrOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutput added in v3.25.0 

func (o ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutputWithContext added in v3.25.0 

func (o ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutputWithContext(ctx context.Context) ResolverQueryLogConfigPtrOutput

type ResolverQueryLogConfigState added in v3.5.0 

type ResolverQueryLogConfigState struct {
	// The ARN (Amazon Resource Name) of the Route 53 Resolver query logging configuration.
	Arn pulumi.StringPtrInput
	// The ARN of the resource that you want Route 53 Resolver to send query logs.
	// You can send query logs to an S3 bucket, a CloudWatch Logs log group, or a Kinesis Data Firehose delivery stream.
	DestinationArn pulumi.StringPtrInput
	// The name of the Route 53 Resolver query logging configuration.
	Name pulumi.StringPtrInput
	// The AWS account ID of the account that created the query logging configuration.
	OwnerId pulumi.StringPtrInput
	// An indication of whether the query logging configuration is shared with other AWS accounts, or was shared with the current account by another AWS account.
	// Sharing is configured through AWS Resource Access Manager (AWS RAM).
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
}

func (ResolverQueryLogConfigState) ElementType added in v3.5.0 

func (ResolverQueryLogConfigState) ElementType() reflect.Type

type ResolverRule 

type ResolverRule struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringOutput `pulumi:"domainName"`
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringOutput `pulumi:"name"`
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrOutput `pulumi:"resolverEndpointId"`
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringOutput `pulumi:"ruleType"`
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringOutput `pulumi:"shareStatus"`
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayOutput `pulumi:"targetIps"`
}

Provides a Route53 Resolver rule.

## Example Usage ### System rule

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRule(ctx, "sys", &route53.ResolverRuleArgs{
			DomainName: pulumi.String("subdomain.example.com"),
			RuleType:   pulumi.String("SYSTEM"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Forward rule

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRule(ctx, "fwd", &route53.ResolverRuleArgs{
			DomainName:         pulumi.String("example.com"),
			RuleType:           pulumi.String("FORWARD"),
			ResolverEndpointId: pulumi.Any(aws_route53_resolver_endpoint.Foo.Id),
			TargetIps: route53.ResolverRuleTargetIpArray{
				&route53.ResolverRuleTargetIpArgs{
					Ip: pulumi.String("123.45.67.89"),
				},
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("Prod"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Resolver rules can be imported using the `id`, e.g.

```sh 

$ pulumi import aws:route53/resolverRule:ResolverRule sys rslvr-rr-0123456789abcdef0

```

func GetResolverRule 

func GetResolverRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverRuleState, opts ...pulumi.ResourceOption) (*ResolverRule, error)

GetResolverRule gets an existing ResolverRule resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverRule 

func NewResolverRule(ctx *pulumi.Context,
	name string, args *ResolverRuleArgs, opts ...pulumi.ResourceOption) (*ResolverRule, error)

NewResolverRule registers a new resource with the given unique name, arguments, and options.

func (*ResolverRule) ElementType added in v3.13.0 

func (*ResolverRule) ElementType() reflect.Type

func (*ResolverRule) ToResolverRuleOutput added in v3.13.0 

func (i *ResolverRule) ToResolverRuleOutput() ResolverRuleOutput

func (*ResolverRule) ToResolverRuleOutputWithContext added in v3.13.0 

func (i *ResolverRule) ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput

func (*ResolverRule) ToResolverRulePtrOutput added in v3.25.0 

func (i *ResolverRule) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (*ResolverRule) ToResolverRulePtrOutputWithContext added in v3.25.0 

func (i *ResolverRule) ToResolverRulePtrOutputWithContext(ctx context.Context) ResolverRulePtrOutput

type ResolverRuleArgs 

type ResolverRuleArgs struct {
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringInput
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringPtrInput
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrInput
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayInput
}

The set of arguments for constructing a ResolverRule resource.

func (ResolverRuleArgs) ElementType 

func (ResolverRuleArgs) ElementType() reflect.Type

type ResolverRuleArray added in v3.25.0 

type ResolverRuleArray []ResolverRuleInput

func (ResolverRuleArray) ElementType added in v3.25.0 

func (ResolverRuleArray) ElementType() reflect.Type

func (ResolverRuleArray) ToResolverRuleArrayOutput added in v3.25.0 

func (i ResolverRuleArray) ToResolverRuleArrayOutput() ResolverRuleArrayOutput

func (ResolverRuleArray) ToResolverRuleArrayOutputWithContext added in v3.25.0 

func (i ResolverRuleArray) ToResolverRuleArrayOutputWithContext(ctx context.Context) ResolverRuleArrayOutput

type ResolverRuleArrayInput added in v3.25.0 

type ResolverRuleArrayInput interface {
	pulumi.Input

	ToResolverRuleArrayOutput() ResolverRuleArrayOutput
	ToResolverRuleArrayOutputWithContext(context.Context) ResolverRuleArrayOutput
}

ResolverRuleArrayInput is an input type that accepts ResolverRuleArray and ResolverRuleArrayOutput values. You can construct a concrete instance of `ResolverRuleArrayInput` via: 

ResolverRuleArray{ ResolverRuleArgs{...} }

type ResolverRuleArrayOutput added in v3.25.0 

type ResolverRuleArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleArrayOutput) ElementType added in v3.25.0 

func (ResolverRuleArrayOutput) ElementType() reflect.Type

func (ResolverRuleArrayOutput) Index added in v3.25.0 

func (o ResolverRuleArrayOutput) Index(i pulumi.IntInput) ResolverRuleOutput

func (ResolverRuleArrayOutput) ToResolverRuleArrayOutput added in v3.25.0 

func (o ResolverRuleArrayOutput) ToResolverRuleArrayOutput() ResolverRuleArrayOutput

func (ResolverRuleArrayOutput) ToResolverRuleArrayOutputWithContext added in v3.25.0 

func (o ResolverRuleArrayOutput) ToResolverRuleArrayOutputWithContext(ctx context.Context) ResolverRuleArrayOutput

type ResolverRuleAssociation 

type ResolverRuleAssociation struct {
	pulumi.CustomResourceState

	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringOutput `pulumi:"resolverRuleId"`
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
}

Provides a Route53 Resolver rule association.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewResolverRuleAssociation(ctx, "example", &route53.ResolverRuleAssociationArgs{
			ResolverRuleId: pulumi.Any(aws_route53_resolver_rule.Sys.Id),
			VpcId:          pulumi.Any(aws_vpc.Foo.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Resolver rule associations can be imported using the `id`, e.g.

```sh 

$ pulumi import aws:route53/resolverRuleAssociation:ResolverRuleAssociation example rslvr-rrassoc-97242eaf88example

```

func GetResolverRuleAssociation 

func GetResolverRuleAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverRuleAssociationState, opts ...pulumi.ResourceOption) (*ResolverRuleAssociation, error)

GetResolverRuleAssociation gets an existing ResolverRuleAssociation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResolverRuleAssociation 

func NewResolverRuleAssociation(ctx *pulumi.Context,
	name string, args *ResolverRuleAssociationArgs, opts ...pulumi.ResourceOption) (*ResolverRuleAssociation, error)

NewResolverRuleAssociation registers a new resource with the given unique name, arguments, and options.

func (*ResolverRuleAssociation) ElementType added in v3.13.0 

func (*ResolverRuleAssociation) ElementType() reflect.Type

func (*ResolverRuleAssociation) ToResolverRuleAssociationOutput added in v3.13.0 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (*ResolverRuleAssociation) ToResolverRuleAssociationOutputWithContext added in v3.13.0 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput

func (*ResolverRuleAssociation) ToResolverRuleAssociationPtrOutput added in v3.25.0 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (*ResolverRuleAssociation) ToResolverRuleAssociationPtrOutputWithContext added in v3.25.0 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationPtrOutputWithContext(ctx context.Context) ResolverRuleAssociationPtrOutput

type ResolverRuleAssociationArgs 

type ResolverRuleAssociationArgs struct {
	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringPtrInput
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringInput
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringInput
}

The set of arguments for constructing a ResolverRuleAssociation resource.

func (ResolverRuleAssociationArgs) ElementType 

func (ResolverRuleAssociationArgs) ElementType() reflect.Type

type ResolverRuleAssociationArray added in v3.25.0 

type ResolverRuleAssociationArray []ResolverRuleAssociationInput

func (ResolverRuleAssociationArray) ElementType added in v3.25.0 

func (ResolverRuleAssociationArray) ElementType() reflect.Type

func (ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutput added in v3.25.0 

func (i ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutput() ResolverRuleAssociationArrayOutput

func (ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutputWithContext added in v3.25.0 

func (i ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutputWithContext(ctx context.Context) ResolverRuleAssociationArrayOutput

type ResolverRuleAssociationArrayInput added in v3.25.0 

type ResolverRuleAssociationArrayInput interface {
	pulumi.Input

	ToResolverRuleAssociationArrayOutput() ResolverRuleAssociationArrayOutput
	ToResolverRuleAssociationArrayOutputWithContext(context.Context) ResolverRuleAssociationArrayOutput
}

ResolverRuleAssociationArrayInput is an input type that accepts ResolverRuleAssociationArray and ResolverRuleAssociationArrayOutput values. You can construct a concrete instance of `ResolverRuleAssociationArrayInput` via: 

ResolverRuleAssociationArray{ ResolverRuleAssociationArgs{...} }

type ResolverRuleAssociationArrayOutput added in v3.25.0 

type ResolverRuleAssociationArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationArrayOutput) ElementType added in v3.25.0 

func (ResolverRuleAssociationArrayOutput) ElementType() reflect.Type

func (ResolverRuleAssociationArrayOutput) Index added in v3.25.0 

func (o ResolverRuleAssociationArrayOutput) Index(i pulumi.IntInput) ResolverRuleAssociationOutput

func (ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutput added in v3.25.0 

func (o ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutput() ResolverRuleAssociationArrayOutput

func (ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutputWithContext added in v3.25.0 

func (o ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutputWithContext(ctx context.Context) ResolverRuleAssociationArrayOutput

type ResolverRuleAssociationInput added in v3.13.0 

type ResolverRuleAssociationInput interface {
	pulumi.Input

	ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput
	ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput
}

type ResolverRuleAssociationMap added in v3.25.0 

type ResolverRuleAssociationMap map[string]ResolverRuleAssociationInput

func (ResolverRuleAssociationMap) ElementType added in v3.25.0 

func (ResolverRuleAssociationMap) ElementType() reflect.Type

func (ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutput added in v3.25.0 

func (i ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutput() ResolverRuleAssociationMapOutput

func (ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutputWithContext added in v3.25.0 

func (i ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutputWithContext(ctx context.Context) ResolverRuleAssociationMapOutput

type ResolverRuleAssociationMapInput added in v3.25.0 

type ResolverRuleAssociationMapInput interface {
	pulumi.Input

	ToResolverRuleAssociationMapOutput() ResolverRuleAssociationMapOutput
	ToResolverRuleAssociationMapOutputWithContext(context.Context) ResolverRuleAssociationMapOutput
}

ResolverRuleAssociationMapInput is an input type that accepts ResolverRuleAssociationMap and ResolverRuleAssociationMapOutput values. You can construct a concrete instance of `ResolverRuleAssociationMapInput` via: 

ResolverRuleAssociationMap{ "key": ResolverRuleAssociationArgs{...} }

type ResolverRuleAssociationMapOutput added in v3.25.0 

type ResolverRuleAssociationMapOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationMapOutput) ElementType added in v3.25.0 

func (ResolverRuleAssociationMapOutput) ElementType() reflect.Type

func (ResolverRuleAssociationMapOutput) MapIndex added in v3.25.0 

func (o ResolverRuleAssociationMapOutput) MapIndex(k pulumi.StringInput) ResolverRuleAssociationOutput

func (ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutput added in v3.25.0 

func (o ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutput() ResolverRuleAssociationMapOutput

func (ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutputWithContext added in v3.25.0 

func (o ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutputWithContext(ctx context.Context) ResolverRuleAssociationMapOutput

type ResolverRuleAssociationOutput added in v3.13.0 

type ResolverRuleAssociationOutput struct {
	*pulumi.OutputState
}

func (ResolverRuleAssociationOutput) ElementType added in v3.13.0 

func (ResolverRuleAssociationOutput) ElementType() reflect.Type

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput added in v3.13.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutputWithContext added in v3.13.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationOutputWithContext(ctx context.Context) ResolverRuleAssociationOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutput added in v3.25.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutputWithContext added in v3.25.0 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutputWithContext(ctx context.Context) ResolverRuleAssociationPtrOutput

type ResolverRuleAssociationPtrInput added in v3.25.0 

type ResolverRuleAssociationPtrInput interface {
	pulumi.Input

	ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput
	ToResolverRuleAssociationPtrOutputWithContext(ctx context.Context) ResolverRuleAssociationPtrOutput
}

type ResolverRuleAssociationPtrOutput added in v3.25.0 

type ResolverRuleAssociationPtrOutput struct {
	*pulumi.OutputState
}

func (ResolverRuleAssociationPtrOutput) ElementType added in v3.25.0 

func (ResolverRuleAssociationPtrOutput) ElementType() reflect.Type

func (ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutput added in v3.25.0 

func (o ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutputWithContext added in v3.25.0 

func (o ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutputWithContext(ctx context.Context) ResolverRuleAssociationPtrOutput

type ResolverRuleAssociationState 

type ResolverRuleAssociationState struct {
	// A name for the association that you're creating between a resolver rule and a VPC.
	Name pulumi.StringPtrInput
	// The ID of the resolver rule that you want to associate with the VPC.
	ResolverRuleId pulumi.StringPtrInput
	// The ID of the VPC that you want to associate the resolver rule with.
	VpcId pulumi.StringPtrInput
}

func (ResolverRuleAssociationState) ElementType 

func (ResolverRuleAssociationState) ElementType() reflect.Type

type ResolverRuleInput added in v3.13.0 

type ResolverRuleInput interface {
	pulumi.Input

	ToResolverRuleOutput() ResolverRuleOutput
	ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput
}

type ResolverRuleMap added in v3.25.0 

type ResolverRuleMap map[string]ResolverRuleInput

func (ResolverRuleMap) ElementType added in v3.25.0 

func (ResolverRuleMap) ElementType() reflect.Type

func (ResolverRuleMap) ToResolverRuleMapOutput added in v3.25.0 

func (i ResolverRuleMap) ToResolverRuleMapOutput() ResolverRuleMapOutput

func (ResolverRuleMap) ToResolverRuleMapOutputWithContext added in v3.25.0 

func (i ResolverRuleMap) ToResolverRuleMapOutputWithContext(ctx context.Context) ResolverRuleMapOutput

type ResolverRuleMapInput added in v3.25.0 

type ResolverRuleMapInput interface {
	pulumi.Input

	ToResolverRuleMapOutput() ResolverRuleMapOutput
	ToResolverRuleMapOutputWithContext(context.Context) ResolverRuleMapOutput
}

ResolverRuleMapInput is an input type that accepts ResolverRuleMap and ResolverRuleMapOutput values. You can construct a concrete instance of `ResolverRuleMapInput` via: 

ResolverRuleMap{ "key": ResolverRuleArgs{...} }

type ResolverRuleMapOutput added in v3.25.0 

type ResolverRuleMapOutput struct{ *pulumi.OutputState }

func (ResolverRuleMapOutput) ElementType added in v3.25.0 

func (ResolverRuleMapOutput) ElementType() reflect.Type

func (ResolverRuleMapOutput) MapIndex added in v3.25.0 

func (o ResolverRuleMapOutput) MapIndex(k pulumi.StringInput) ResolverRuleOutput

func (ResolverRuleMapOutput) ToResolverRuleMapOutput added in v3.25.0 

func (o ResolverRuleMapOutput) ToResolverRuleMapOutput() ResolverRuleMapOutput

func (ResolverRuleMapOutput) ToResolverRuleMapOutputWithContext added in v3.25.0 

func (o ResolverRuleMapOutput) ToResolverRuleMapOutputWithContext(ctx context.Context) ResolverRuleMapOutput

type ResolverRuleOutput added in v3.13.0 

type ResolverRuleOutput struct {
	*pulumi.OutputState
}

func (ResolverRuleOutput) ElementType added in v3.13.0 

func (ResolverRuleOutput) ElementType() reflect.Type

func (ResolverRuleOutput) ToResolverRuleOutput added in v3.13.0 

func (o ResolverRuleOutput) ToResolverRuleOutput() ResolverRuleOutput

func (ResolverRuleOutput) ToResolverRuleOutputWithContext added in v3.13.0 

func (o ResolverRuleOutput) ToResolverRuleOutputWithContext(ctx context.Context) ResolverRuleOutput

func (ResolverRuleOutput) ToResolverRulePtrOutput added in v3.25.0 

func (o ResolverRuleOutput) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (ResolverRuleOutput) ToResolverRulePtrOutputWithContext added in v3.25.0 

func (o ResolverRuleOutput) ToResolverRulePtrOutputWithContext(ctx context.Context) ResolverRulePtrOutput

type ResolverRulePtrInput added in v3.25.0 

type ResolverRulePtrInput interface {
	pulumi.Input

	ToResolverRulePtrOutput() ResolverRulePtrOutput
	ToResolverRulePtrOutputWithContext(ctx context.Context) ResolverRulePtrOutput
}

type ResolverRulePtrOutput added in v3.25.0 

type ResolverRulePtrOutput struct {
	*pulumi.OutputState
}

func (ResolverRulePtrOutput) ElementType added in v3.25.0 

func (ResolverRulePtrOutput) ElementType() reflect.Type

func (ResolverRulePtrOutput) ToResolverRulePtrOutput added in v3.25.0 

func (o ResolverRulePtrOutput) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (ResolverRulePtrOutput) ToResolverRulePtrOutputWithContext added in v3.25.0 

func (o ResolverRulePtrOutput) ToResolverRulePtrOutputWithContext(ctx context.Context) ResolverRulePtrOutput

type ResolverRuleState 

type ResolverRuleState struct {
	// The ARN (Amazon Resource Name) for the resolver rule.
	Arn pulumi.StringPtrInput
	// DNS queries for this domain name are forwarded to the IP addresses that are specified using `targetIp`.
	DomainName pulumi.StringPtrInput
	// A friendly name that lets you easily find a rule in the Resolver dashboard in the Route 53 console.
	Name pulumi.StringPtrInput
	// When a rule is shared with another AWS account, the account ID of the account that the rule is shared with.
	OwnerId pulumi.StringPtrInput
	// The ID of the outbound resolver endpoint that you want to use to route DNS queries to the IP addresses that you specify using `targetIp`.
	// This argument should only be specified for `FORWARD` type rules.
	ResolverEndpointId pulumi.StringPtrInput
	// The rule type. Valid values are `FORWARD`, `SYSTEM` and `RECURSIVE`.
	RuleType pulumi.StringPtrInput
	// Whether the rules is shared and, if so, whether the current account is sharing the rule with another account, or another account is sharing the rule with the current account.
	// Values are `NOT_SHARED`, `SHARED_BY_ME` or `SHARED_WITH_ME`
	ShareStatus pulumi.StringPtrInput
	// A map of tags to assign to the resource.
	Tags pulumi.StringMapInput
	// Configuration block(s) indicating the IPs that you want Resolver to forward DNS queries to (documented below).
	// This argument should only be specified for `FORWARD` type rules.
	TargetIps ResolverRuleTargetIpArrayInput
}

func (ResolverRuleState) ElementType 

func (ResolverRuleState) ElementType() reflect.Type

type ResolverRuleTargetIp 

type ResolverRuleTargetIp struct {
	// One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.
	Ip string `pulumi:"ip"`
	// The port at `ip` that you want to forward DNS queries to. Default value is `53`
	Port *int `pulumi:"port"`
}

type ResolverRuleTargetIpArgs 

type ResolverRuleTargetIpArgs struct {
	// One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.
	Ip pulumi.StringInput `pulumi:"ip"`
	// The port at `ip` that you want to forward DNS queries to. Default value is `53`
	Port pulumi.IntPtrInput `pulumi:"port"`
}

func (ResolverRuleTargetIpArgs) ElementType 

func (ResolverRuleTargetIpArgs) ElementType() reflect.Type

func (ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutput 

func (i ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutputWithContext 

func (i ResolverRuleTargetIpArgs) ToResolverRuleTargetIpOutputWithContext(ctx context.Context) ResolverRuleTargetIpOutput

type ResolverRuleTargetIpArray 

type ResolverRuleTargetIpArray []ResolverRuleTargetIpInput

func (ResolverRuleTargetIpArray) ElementType 

func (ResolverRuleTargetIpArray) ElementType() reflect.Type

func (ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutput 

func (i ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput

func (ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutputWithContext 

func (i ResolverRuleTargetIpArray) ToResolverRuleTargetIpArrayOutputWithContext(ctx context.Context) ResolverRuleTargetIpArrayOutput

type ResolverRuleTargetIpArrayInput 

type ResolverRuleTargetIpArrayInput interface {
	pulumi.Input

	ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput
	ToResolverRuleTargetIpArrayOutputWithContext(context.Context) ResolverRuleTargetIpArrayOutput
}

ResolverRuleTargetIpArrayInput is an input type that accepts ResolverRuleTargetIpArray and ResolverRuleTargetIpArrayOutput values. You can construct a concrete instance of `ResolverRuleTargetIpArrayInput` via: 

ResolverRuleTargetIpArray{ ResolverRuleTargetIpArgs{...} }

type ResolverRuleTargetIpArrayOutput 

type ResolverRuleTargetIpArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleTargetIpArrayOutput) ElementType 

func (ResolverRuleTargetIpArrayOutput) ElementType() reflect.Type

func (ResolverRuleTargetIpArrayOutput) Index 

func (o ResolverRuleTargetIpArrayOutput) Index(i pulumi.IntInput) ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutput 

func (o ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutput() ResolverRuleTargetIpArrayOutput

func (ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutputWithContext 

func (o ResolverRuleTargetIpArrayOutput) ToResolverRuleTargetIpArrayOutputWithContext(ctx context.Context) ResolverRuleTargetIpArrayOutput

type ResolverRuleTargetIpInput 

type ResolverRuleTargetIpInput interface {
	pulumi.Input

	ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput
	ToResolverRuleTargetIpOutputWithContext(context.Context) ResolverRuleTargetIpOutput
}

ResolverRuleTargetIpInput is an input type that accepts ResolverRuleTargetIpArgs and ResolverRuleTargetIpOutput values. You can construct a concrete instance of `ResolverRuleTargetIpInput` via: 

ResolverRuleTargetIpArgs{...}

type ResolverRuleTargetIpOutput 

type ResolverRuleTargetIpOutput struct{ *pulumi.OutputState }

func (ResolverRuleTargetIpOutput) ElementType 

func (ResolverRuleTargetIpOutput) ElementType() reflect.Type

func (ResolverRuleTargetIpOutput) Ip 

func (o ResolverRuleTargetIpOutput) Ip() pulumi.StringOutput

One IP address that you want to forward DNS queries to. You can specify only IPv4 addresses.

func (ResolverRuleTargetIpOutput) Port 

func (o ResolverRuleTargetIpOutput) Port() pulumi.IntPtrOutput

The port at `ip` that you want to forward DNS queries to. Default value is `53`

func (ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutput 

func (o ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutput() ResolverRuleTargetIpOutput

func (ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutputWithContext 

func (o ResolverRuleTargetIpOutput) ToResolverRuleTargetIpOutputWithContext(ctx context.Context) ResolverRuleTargetIpOutput

type VpcAssociationAuthorization added in v3.1.0 

type VpcAssociationAuthorization struct {
	pulumi.CustomResourceState

	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringOutput `pulumi:"vpcRegion"`
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Authorizes a VPC in a peer account to be associated with a local Route53 Hosted Zone.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "alternate", nil)
		if err != nil {
			return err
		}
		exampleVpc, err := ec2.NewVpc(ctx, "exampleVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.6.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleZone, err := route53.NewZone(ctx, "exampleZone", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: exampleVpc.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		alternateVpc, err := ec2.NewVpc(ctx, "alternateVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.7.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		}, pulumi.Provider("aws.alternate"))
		if err != nil {
			return err
		}
		exampleVpcAssociationAuthorization, err := route53.NewVpcAssociationAuthorization(ctx, "exampleVpcAssociationAuthorization", &route53.VpcAssociationAuthorizationArgs{
			VpcId:  alternateVpc.ID(),
			ZoneId: exampleZone.ID(),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZoneAssociation(ctx, "exampleZoneAssociation", &route53.ZoneAssociationArgs{
			VpcId:  exampleVpcAssociationAuthorization.VpcId,
			ZoneId: exampleVpcAssociationAuthorization.ZoneId,
		}, pulumi.Provider("aws.alternate"))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route 53 VPC Association Authorizations can be imported via the Hosted Zone ID and VPC ID, separated by a colon (`:`), e.g.

```sh 

$ pulumi import aws:route53/vpcAssociationAuthorization:VpcAssociationAuthorization example Z123456ABCDEFG:vpc-12345678

```

func GetVpcAssociationAuthorization added in v3.1.0 

func GetVpcAssociationAuthorization(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpcAssociationAuthorizationState, opts ...pulumi.ResourceOption) (*VpcAssociationAuthorization, error)

GetVpcAssociationAuthorization gets an existing VpcAssociationAuthorization resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVpcAssociationAuthorization added in v3.1.0 

func NewVpcAssociationAuthorization(ctx *pulumi.Context,
	name string, args *VpcAssociationAuthorizationArgs, opts ...pulumi.ResourceOption) (*VpcAssociationAuthorization, error)

NewVpcAssociationAuthorization registers a new resource with the given unique name, arguments, and options.

func (*VpcAssociationAuthorization) ElementType added in v3.13.0 

func (*VpcAssociationAuthorization) ElementType() reflect.Type

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput added in v3.13.0 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutputWithContext added in v3.13.0 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutput added in v3.25.0 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutputWithContext added in v3.25.0 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutputWithContext(ctx context.Context) VpcAssociationAuthorizationPtrOutput

type VpcAssociationAuthorizationArgs added in v3.1.0 

type VpcAssociationAuthorizationArgs struct {
	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a VpcAssociationAuthorization resource.

func (VpcAssociationAuthorizationArgs) ElementType added in v3.1.0 

func (VpcAssociationAuthorizationArgs) ElementType() reflect.Type

type VpcAssociationAuthorizationArray added in v3.25.0 

type VpcAssociationAuthorizationArray []VpcAssociationAuthorizationInput

func (VpcAssociationAuthorizationArray) ElementType added in v3.25.0 

func (VpcAssociationAuthorizationArray) ElementType() reflect.Type

func (VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutput added in v3.25.0 

func (i VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutput() VpcAssociationAuthorizationArrayOutput

func (VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutputWithContext added in v3.25.0 

func (i VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutputWithContext(ctx context.Context) VpcAssociationAuthorizationArrayOutput

type VpcAssociationAuthorizationArrayInput added in v3.25.0 

type VpcAssociationAuthorizationArrayInput interface {
	pulumi.Input

	ToVpcAssociationAuthorizationArrayOutput() VpcAssociationAuthorizationArrayOutput
	ToVpcAssociationAuthorizationArrayOutputWithContext(context.Context) VpcAssociationAuthorizationArrayOutput
}

VpcAssociationAuthorizationArrayInput is an input type that accepts VpcAssociationAuthorizationArray and VpcAssociationAuthorizationArrayOutput values. You can construct a concrete instance of `VpcAssociationAuthorizationArrayInput` via: 

VpcAssociationAuthorizationArray{ VpcAssociationAuthorizationArgs{...} }

type VpcAssociationAuthorizationArrayOutput added in v3.25.0 

type VpcAssociationAuthorizationArrayOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationArrayOutput) ElementType added in v3.25.0 

func (VpcAssociationAuthorizationArrayOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationArrayOutput) Index added in v3.25.0 

func (o VpcAssociationAuthorizationArrayOutput) Index(i pulumi.IntInput) VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutput added in v3.25.0 

func (o VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutput() VpcAssociationAuthorizationArrayOutput

func (VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutputWithContext added in v3.25.0 

func (o VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutputWithContext(ctx context.Context) VpcAssociationAuthorizationArrayOutput

type VpcAssociationAuthorizationInput added in v3.13.0 

type VpcAssociationAuthorizationInput interface {
	pulumi.Input

	ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput
	ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput
}

type VpcAssociationAuthorizationMap added in v3.25.0 

type VpcAssociationAuthorizationMap map[string]VpcAssociationAuthorizationInput

func (VpcAssociationAuthorizationMap) ElementType added in v3.25.0 

func (VpcAssociationAuthorizationMap) ElementType() reflect.Type

func (VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutput added in v3.25.0 

func (i VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutput() VpcAssociationAuthorizationMapOutput

func (VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutputWithContext added in v3.25.0 

func (i VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutputWithContext(ctx context.Context) VpcAssociationAuthorizationMapOutput

type VpcAssociationAuthorizationMapInput added in v3.25.0 

type VpcAssociationAuthorizationMapInput interface {
	pulumi.Input

	ToVpcAssociationAuthorizationMapOutput() VpcAssociationAuthorizationMapOutput
	ToVpcAssociationAuthorizationMapOutputWithContext(context.Context) VpcAssociationAuthorizationMapOutput
}

VpcAssociationAuthorizationMapInput is an input type that accepts VpcAssociationAuthorizationMap and VpcAssociationAuthorizationMapOutput values. You can construct a concrete instance of `VpcAssociationAuthorizationMapInput` via: 

VpcAssociationAuthorizationMap{ "key": VpcAssociationAuthorizationArgs{...} }

type VpcAssociationAuthorizationMapOutput added in v3.25.0 

type VpcAssociationAuthorizationMapOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationMapOutput) ElementType added in v3.25.0 

func (VpcAssociationAuthorizationMapOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationMapOutput) MapIndex added in v3.25.0 

func (o VpcAssociationAuthorizationMapOutput) MapIndex(k pulumi.StringInput) VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutput added in v3.25.0 

func (o VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutput() VpcAssociationAuthorizationMapOutput

func (VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutputWithContext added in v3.25.0 

func (o VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutputWithContext(ctx context.Context) VpcAssociationAuthorizationMapOutput

type VpcAssociationAuthorizationOutput added in v3.13.0 

type VpcAssociationAuthorizationOutput struct {
	*pulumi.OutputState
}

func (VpcAssociationAuthorizationOutput) ElementType added in v3.13.0 

func (VpcAssociationAuthorizationOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput added in v3.13.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutputWithContext added in v3.13.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutputWithContext(ctx context.Context) VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutput added in v3.25.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutputWithContext added in v3.25.0 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutputWithContext(ctx context.Context) VpcAssociationAuthorizationPtrOutput

type VpcAssociationAuthorizationPtrInput added in v3.25.0 

type VpcAssociationAuthorizationPtrInput interface {
	pulumi.Input

	ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput
	ToVpcAssociationAuthorizationPtrOutputWithContext(ctx context.Context) VpcAssociationAuthorizationPtrOutput
}

type VpcAssociationAuthorizationPtrOutput added in v3.25.0 

type VpcAssociationAuthorizationPtrOutput struct {
	*pulumi.OutputState
}

func (VpcAssociationAuthorizationPtrOutput) ElementType added in v3.25.0 

func (VpcAssociationAuthorizationPtrOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutput added in v3.25.0 

func (o VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutputWithContext added in v3.25.0 

func (o VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutputWithContext(ctx context.Context) VpcAssociationAuthorizationPtrOutput

type VpcAssociationAuthorizationState added in v3.1.0 

type VpcAssociationAuthorizationState struct {
	// The VPC to authorize for association with the private hosted zone.
	VpcId pulumi.StringPtrInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The ID of the private hosted zone that you want to authorize associating a VPC with.
	ZoneId pulumi.StringPtrInput
}

func (VpcAssociationAuthorizationState) ElementType added in v3.1.0 

func (VpcAssociationAuthorizationState) ElementType() reflect.Type

type Zone 

type Zone struct {
	pulumi.CustomResourceState

	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringOutput `pulumi:"comment"`
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrOutput `pulumi:"delegationSetId"`
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	// This is the name of the hosted zone.
	Name pulumi.StringOutput `pulumi:"name"`
	// A list of name servers in associated (or default) delegation set.
	// Find more about delegation sets in [AWS docs](https://docs.aws.amazon.com/Route53/latest/APIReference/actions-on-reusable-delegation-sets.html).
	NameServers pulumi.StringArrayOutput `pulumi:"nameServers"`
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayOutput `pulumi:"vpcs"`
	// The Hosted Zone ID. This can be referenced by zone records.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Manages a Route53 Hosted Zone.

## Example Usage ### Public Zone

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewZone(ctx, "primary", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Public Subdomain Zone

For use in subdomains, note that you need to create a `route53.Record` of type `NS` as well as the subdomain zone.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := route53.NewZone(ctx, "main", nil)
		if err != nil {
			return err
		}
		dev, err := route53.NewZone(ctx, "dev", &route53.ZoneArgs{
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("dev"),
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewRecord(ctx, "dev_ns", &route53.RecordArgs{
			ZoneId:  main.ZoneId,
			Name:    pulumi.String("dev.example.com"),
			Type:    pulumi.String("NS"),
			Ttl:     pulumi.Int(30),
			Records: dev.NameServers,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Private Zone

> **NOTE:** This provider provides both exclusive VPC associations defined in-line in this resource via `vpc` configuration blocks and a separate ` Zone VPC Association resource. At this time, you cannot use in-line VPC associations in conjunction with any `route53.ZoneAssociation` resources with the same zone ID otherwise it will cause a perpetual difference in plan output. You can optionally use [ `ignoreChanges` ](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) to manage additional associations via the `route53.ZoneAssociation` resource.

> **NOTE:** Private zones require at least one VPC association at all times.

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewZone(ctx, "private", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: pulumi.Any(aws_vpc.Example.Id),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route53 Zones can be imported using the `zone id`, e.g.

```sh 

$ pulumi import aws:route53/zone:Zone myzone Z1D633PJN98FT9

```

func GetZone 

func GetZone(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ZoneState, opts ...pulumi.ResourceOption) (*Zone, error)

GetZone gets an existing Zone resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewZone 

func NewZone(ctx *pulumi.Context,
	name string, args *ZoneArgs, opts ...pulumi.ResourceOption) (*Zone, error)

NewZone registers a new resource with the given unique name, arguments, and options.

func (*Zone) ElementType added in v3.13.0 

func (*Zone) ElementType() reflect.Type

func (*Zone) ToZoneOutput added in v3.13.0 

func (i *Zone) ToZoneOutput() ZoneOutput

func (*Zone) ToZoneOutputWithContext added in v3.13.0 

func (i *Zone) ToZoneOutputWithContext(ctx context.Context) ZoneOutput

func (*Zone) ToZonePtrOutput added in v3.25.0 

func (i *Zone) ToZonePtrOutput() ZonePtrOutput

func (*Zone) ToZonePtrOutputWithContext added in v3.25.0 

func (i *Zone) ToZonePtrOutputWithContext(ctx context.Context) ZonePtrOutput

type ZoneArgs 

type ZoneArgs struct {
	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringPtrInput
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrInput
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrInput
	// This is the name of the hosted zone.
	Name pulumi.StringPtrInput
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapInput
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayInput
}

The set of arguments for constructing a Zone resource.

func (ZoneArgs) ElementType 

func (ZoneArgs) ElementType() reflect.Type

type ZoneArray added in v3.25.0 

type ZoneArray []ZoneInput

func (ZoneArray) ElementType added in v3.25.0 

func (ZoneArray) ElementType() reflect.Type

func (ZoneArray) ToZoneArrayOutput added in v3.25.0 

func (i ZoneArray) ToZoneArrayOutput() ZoneArrayOutput

func (ZoneArray) ToZoneArrayOutputWithContext added in v3.25.0 

func (i ZoneArray) ToZoneArrayOutputWithContext(ctx context.Context) ZoneArrayOutput

type ZoneArrayInput added in v3.25.0 

type ZoneArrayInput interface {
	pulumi.Input

	ToZoneArrayOutput() ZoneArrayOutput
	ToZoneArrayOutputWithContext(context.Context) ZoneArrayOutput
}

ZoneArrayInput is an input type that accepts ZoneArray and ZoneArrayOutput values. You can construct a concrete instance of `ZoneArrayInput` via: 

ZoneArray{ ZoneArgs{...} }

type ZoneArrayOutput added in v3.25.0 

type ZoneArrayOutput struct{ *pulumi.OutputState }

func (ZoneArrayOutput) ElementType added in v3.25.0 

func (ZoneArrayOutput) ElementType() reflect.Type

func (ZoneArrayOutput) Index added in v3.25.0 

func (o ZoneArrayOutput) Index(i pulumi.IntInput) ZoneOutput

func (ZoneArrayOutput) ToZoneArrayOutput added in v3.25.0 

func (o ZoneArrayOutput) ToZoneArrayOutput() ZoneArrayOutput

func (ZoneArrayOutput) ToZoneArrayOutputWithContext added in v3.25.0 

func (o ZoneArrayOutput) ToZoneArrayOutputWithContext(ctx context.Context) ZoneArrayOutput

type ZoneAssociation 

type ZoneAssociation struct {
	pulumi.CustomResourceState

	// The account ID of the account that created the hosted zone.
	OwningAccount pulumi.StringOutput `pulumi:"owningAccount"`
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringOutput `pulumi:"vpcRegion"`
	// The private hosted zone to associate.
	ZoneId pulumi.StringOutput `pulumi:"zoneId"`
}

Manages a Route53 Hosted Zone VPC association. VPC associations can only be made on private zones. See the `route53.VpcAssociationAuthorization` resource for setting up cross-account associations.

> **NOTE:** Unless explicit association ordering is required (e.g. a separate cross-account association authorization), usage of this resource is not recommended. Use the `vpc` configuration blocks available within the `route53.Zone` resource instead.

> **NOTE:** This provider provides both this standalone Zone VPC Association resource and exclusive VPC associations defined in-line in the `route53.Zone` resource via `vpc` configuration blocks. At this time, you cannot use those in-line VPC associations in conjunction with this resource and the same zone ID otherwise it will cause a perpetual difference in plan output. You can optionally use [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) in the `route53.Zone` resource to manage additional associations via this resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		primary, err := ec2.NewVpc(ctx, "primary", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.6.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		secondaryVpc, err := ec2.NewVpc(ctx, "secondaryVpc", &ec2.VpcArgs{
			CidrBlock:          pulumi.String("10.7.0.0/16"),
			EnableDnsHostnames: pulumi.Bool(true),
			EnableDnsSupport:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		example, err := route53.NewZone(ctx, "example", &route53.ZoneArgs{
			Vpcs: route53.ZoneVpcArray{
				&route53.ZoneVpcArgs{
					VpcId: primary.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = route53.NewZoneAssociation(ctx, "secondaryZoneAssociation", &route53.ZoneAssociationArgs{
			ZoneId: example.ZoneId,
			VpcId:  secondaryVpc.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route 53 Hosted Zone Associations can be imported via the Hosted Zone ID and VPC ID, separated by a colon (`:`), e.g.

```sh 

$ pulumi import aws:route53/zoneAssociation:ZoneAssociation example Z123456ABCDEFG:vpc-12345678

``` 

If the VPC is in a different region than the Terraform AWS Provider region configuration, the VPC Region can be added to the end. e.g.

```sh 

$ pulumi import aws:route53/zoneAssociation:ZoneAssociation example Z123456ABCDEFG:vpc-12345678:us-east-2

```

func GetZoneAssociation 

func GetZoneAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ZoneAssociationState, opts ...pulumi.ResourceOption) (*ZoneAssociation, error)

GetZoneAssociation gets an existing ZoneAssociation resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewZoneAssociation 

func NewZoneAssociation(ctx *pulumi.Context,
	name string, args *ZoneAssociationArgs, opts ...pulumi.ResourceOption) (*ZoneAssociation, error)

NewZoneAssociation registers a new resource with the given unique name, arguments, and options.

func (*ZoneAssociation) ElementType added in v3.13.0 

func (*ZoneAssociation) ElementType() reflect.Type

func (*ZoneAssociation) ToZoneAssociationOutput added in v3.13.0 

func (i *ZoneAssociation) ToZoneAssociationOutput() ZoneAssociationOutput

func (*ZoneAssociation) ToZoneAssociationOutputWithContext added in v3.13.0 

func (i *ZoneAssociation) ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput

func (*ZoneAssociation) ToZoneAssociationPtrOutput added in v3.25.0 

func (i *ZoneAssociation) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (*ZoneAssociation) ToZoneAssociationPtrOutputWithContext added in v3.25.0 

func (i *ZoneAssociation) ToZoneAssociationPtrOutputWithContext(ctx context.Context) ZoneAssociationPtrOutput

type ZoneAssociationArgs 

type ZoneAssociationArgs struct {
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The private hosted zone to associate.
	ZoneId pulumi.StringInput
}

The set of arguments for constructing a ZoneAssociation resource.

func (ZoneAssociationArgs) ElementType 

func (ZoneAssociationArgs) ElementType() reflect.Type

type ZoneAssociationArray added in v3.25.0 

type ZoneAssociationArray []ZoneAssociationInput

func (ZoneAssociationArray) ElementType added in v3.25.0 

func (ZoneAssociationArray) ElementType() reflect.Type

func (ZoneAssociationArray) ToZoneAssociationArrayOutput added in v3.25.0 

func (i ZoneAssociationArray) ToZoneAssociationArrayOutput() ZoneAssociationArrayOutput

func (ZoneAssociationArray) ToZoneAssociationArrayOutputWithContext added in v3.25.0 

func (i ZoneAssociationArray) ToZoneAssociationArrayOutputWithContext(ctx context.Context) ZoneAssociationArrayOutput

type ZoneAssociationArrayInput added in v3.25.0 

type ZoneAssociationArrayInput interface {
	pulumi.Input

	ToZoneAssociationArrayOutput() ZoneAssociationArrayOutput
	ToZoneAssociationArrayOutputWithContext(context.Context) ZoneAssociationArrayOutput
}

ZoneAssociationArrayInput is an input type that accepts ZoneAssociationArray and ZoneAssociationArrayOutput values. You can construct a concrete instance of `ZoneAssociationArrayInput` via: 

ZoneAssociationArray{ ZoneAssociationArgs{...} }

type ZoneAssociationArrayOutput added in v3.25.0 

type ZoneAssociationArrayOutput struct{ *pulumi.OutputState }

func (ZoneAssociationArrayOutput) ElementType added in v3.25.0 

func (ZoneAssociationArrayOutput) ElementType() reflect.Type

func (ZoneAssociationArrayOutput) Index added in v3.25.0 

func (o ZoneAssociationArrayOutput) Index(i pulumi.IntInput) ZoneAssociationOutput

func (ZoneAssociationArrayOutput) ToZoneAssociationArrayOutput added in v3.25.0 

func (o ZoneAssociationArrayOutput) ToZoneAssociationArrayOutput() ZoneAssociationArrayOutput

func (ZoneAssociationArrayOutput) ToZoneAssociationArrayOutputWithContext added in v3.25.0 

func (o ZoneAssociationArrayOutput) ToZoneAssociationArrayOutputWithContext(ctx context.Context) ZoneAssociationArrayOutput

type ZoneAssociationInput added in v3.13.0 

type ZoneAssociationInput interface {
	pulumi.Input

	ToZoneAssociationOutput() ZoneAssociationOutput
	ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput
}

type ZoneAssociationMap added in v3.25.0 

type ZoneAssociationMap map[string]ZoneAssociationInput

func (ZoneAssociationMap) ElementType added in v3.25.0 

func (ZoneAssociationMap) ElementType() reflect.Type

func (ZoneAssociationMap) ToZoneAssociationMapOutput added in v3.25.0 

func (i ZoneAssociationMap) ToZoneAssociationMapOutput() ZoneAssociationMapOutput

func (ZoneAssociationMap) ToZoneAssociationMapOutputWithContext added in v3.25.0 

func (i ZoneAssociationMap) ToZoneAssociationMapOutputWithContext(ctx context.Context) ZoneAssociationMapOutput

type ZoneAssociationMapInput added in v3.25.0 

type ZoneAssociationMapInput interface {
	pulumi.Input

	ToZoneAssociationMapOutput() ZoneAssociationMapOutput
	ToZoneAssociationMapOutputWithContext(context.Context) ZoneAssociationMapOutput
}

ZoneAssociationMapInput is an input type that accepts ZoneAssociationMap and ZoneAssociationMapOutput values. You can construct a concrete instance of `ZoneAssociationMapInput` via: 

ZoneAssociationMap{ "key": ZoneAssociationArgs{...} }

type ZoneAssociationMapOutput added in v3.25.0 

type ZoneAssociationMapOutput struct{ *pulumi.OutputState }

func (ZoneAssociationMapOutput) ElementType added in v3.25.0 

func (ZoneAssociationMapOutput) ElementType() reflect.Type

func (ZoneAssociationMapOutput) MapIndex added in v3.25.0 

func (o ZoneAssociationMapOutput) MapIndex(k pulumi.StringInput) ZoneAssociationOutput

func (ZoneAssociationMapOutput) ToZoneAssociationMapOutput added in v3.25.0 

func (o ZoneAssociationMapOutput) ToZoneAssociationMapOutput() ZoneAssociationMapOutput

func (ZoneAssociationMapOutput) ToZoneAssociationMapOutputWithContext added in v3.25.0 

func (o ZoneAssociationMapOutput) ToZoneAssociationMapOutputWithContext(ctx context.Context) ZoneAssociationMapOutput

type ZoneAssociationOutput added in v3.13.0 

type ZoneAssociationOutput struct {
	*pulumi.OutputState
}

func (ZoneAssociationOutput) ElementType added in v3.13.0 

func (ZoneAssociationOutput) ElementType() reflect.Type

func (ZoneAssociationOutput) ToZoneAssociationOutput added in v3.13.0 

func (o ZoneAssociationOutput) ToZoneAssociationOutput() ZoneAssociationOutput

func (ZoneAssociationOutput) ToZoneAssociationOutputWithContext added in v3.13.0 

func (o ZoneAssociationOutput) ToZoneAssociationOutputWithContext(ctx context.Context) ZoneAssociationOutput

func (ZoneAssociationOutput) ToZoneAssociationPtrOutput added in v3.25.0 

func (o ZoneAssociationOutput) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (ZoneAssociationOutput) ToZoneAssociationPtrOutputWithContext added in v3.25.0 

func (o ZoneAssociationOutput) ToZoneAssociationPtrOutputWithContext(ctx context.Context) ZoneAssociationPtrOutput

type ZoneAssociationPtrInput added in v3.25.0 

type ZoneAssociationPtrInput interface {
	pulumi.Input

	ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput
	ToZoneAssociationPtrOutputWithContext(ctx context.Context) ZoneAssociationPtrOutput
}

type ZoneAssociationPtrOutput added in v3.25.0 

type ZoneAssociationPtrOutput struct {
	*pulumi.OutputState
}

func (ZoneAssociationPtrOutput) ElementType added in v3.25.0 

func (ZoneAssociationPtrOutput) ElementType() reflect.Type

func (ZoneAssociationPtrOutput) ToZoneAssociationPtrOutput added in v3.25.0 

func (o ZoneAssociationPtrOutput) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (ZoneAssociationPtrOutput) ToZoneAssociationPtrOutputWithContext added in v3.25.0 

func (o ZoneAssociationPtrOutput) ToZoneAssociationPtrOutputWithContext(ctx context.Context) ZoneAssociationPtrOutput

type ZoneAssociationState 

type ZoneAssociationState struct {
	// The account ID of the account that created the hosted zone.
	OwningAccount pulumi.StringPtrInput
	// The VPC to associate with the private hosted zone.
	VpcId pulumi.StringPtrInput
	// The VPC's region. Defaults to the region of the AWS provider.
	VpcRegion pulumi.StringPtrInput
	// The private hosted zone to associate.
	ZoneId pulumi.StringPtrInput
}

func (ZoneAssociationState) ElementType 

func (ZoneAssociationState) ElementType() reflect.Type

type ZoneInput added in v3.13.0 

type ZoneInput interface {
	pulumi.Input

	ToZoneOutput() ZoneOutput
	ToZoneOutputWithContext(ctx context.Context) ZoneOutput
}

type ZoneMap added in v3.25.0 

type ZoneMap map[string]ZoneInput

func (ZoneMap) ElementType added in v3.25.0 

func (ZoneMap) ElementType() reflect.Type

func (ZoneMap) ToZoneMapOutput added in v3.25.0 

func (i ZoneMap) ToZoneMapOutput() ZoneMapOutput

func (ZoneMap) ToZoneMapOutputWithContext added in v3.25.0 

func (i ZoneMap) ToZoneMapOutputWithContext(ctx context.Context) ZoneMapOutput

type ZoneMapInput added in v3.25.0 

type ZoneMapInput interface {
	pulumi.Input

	ToZoneMapOutput() ZoneMapOutput
	ToZoneMapOutputWithContext(context.Context) ZoneMapOutput
}

ZoneMapInput is an input type that accepts ZoneMap and ZoneMapOutput values. You can construct a concrete instance of `ZoneMapInput` via: 

ZoneMap{ "key": ZoneArgs{...} }

type ZoneMapOutput added in v3.25.0 

type ZoneMapOutput struct{ *pulumi.OutputState }

func (ZoneMapOutput) ElementType added in v3.25.0 

func (ZoneMapOutput) ElementType() reflect.Type

func (ZoneMapOutput) MapIndex added in v3.25.0 

func (o ZoneMapOutput) MapIndex(k pulumi.StringInput) ZoneOutput

func (ZoneMapOutput) ToZoneMapOutput added in v3.25.0 

func (o ZoneMapOutput) ToZoneMapOutput() ZoneMapOutput

func (ZoneMapOutput) ToZoneMapOutputWithContext added in v3.25.0 

func (o ZoneMapOutput) ToZoneMapOutputWithContext(ctx context.Context) ZoneMapOutput

type ZoneOutput added in v3.13.0 

type ZoneOutput struct {
	*pulumi.OutputState
}

func (ZoneOutput) ElementType added in v3.13.0 

func (ZoneOutput) ElementType() reflect.Type

func (ZoneOutput) ToZoneOutput added in v3.13.0 

func (o ZoneOutput) ToZoneOutput() ZoneOutput

func (ZoneOutput) ToZoneOutputWithContext added in v3.13.0 

func (o ZoneOutput) ToZoneOutputWithContext(ctx context.Context) ZoneOutput

func (ZoneOutput) ToZonePtrOutput added in v3.25.0 

func (o ZoneOutput) ToZonePtrOutput() ZonePtrOutput

func (ZoneOutput) ToZonePtrOutputWithContext added in v3.25.0 

func (o ZoneOutput) ToZonePtrOutputWithContext(ctx context.Context) ZonePtrOutput

type ZonePtrInput added in v3.25.0 

type ZonePtrInput interface {
	pulumi.Input

	ToZonePtrOutput() ZonePtrOutput
	ToZonePtrOutputWithContext(ctx context.Context) ZonePtrOutput
}

type ZonePtrOutput added in v3.25.0 

type ZonePtrOutput struct {
	*pulumi.OutputState
}

func (ZonePtrOutput) ElementType added in v3.25.0 

func (ZonePtrOutput) ElementType() reflect.Type

func (ZonePtrOutput) ToZonePtrOutput added in v3.25.0 

func (o ZonePtrOutput) ToZonePtrOutput() ZonePtrOutput

func (ZonePtrOutput) ToZonePtrOutputWithContext added in v3.25.0 

func (o ZonePtrOutput) ToZonePtrOutputWithContext(ctx context.Context) ZonePtrOutput

type ZoneState 

type ZoneState struct {
	// A comment for the hosted zone. Defaults to 'Managed by Pulumi'.
	Comment pulumi.StringPtrInput
	// The ID of the reusable delegation set whose NS records you want to assign to the hosted zone. Conflicts with `vpc` as delegation sets can only be used for public zones.
	DelegationSetId pulumi.StringPtrInput
	// Whether to destroy all records (possibly managed outside of this provider) in the zone when destroying the zone.
	ForceDestroy pulumi.BoolPtrInput
	// This is the name of the hosted zone.
	Name pulumi.StringPtrInput
	// A list of name servers in associated (or default) delegation set.
	// Find more about delegation sets in [AWS docs](https://docs.aws.amazon.com/Route53/latest/APIReference/actions-on-reusable-delegation-sets.html).
	NameServers pulumi.StringArrayInput
	// A mapping of tags to assign to the zone.
	Tags pulumi.StringMapInput
	// Configuration block(s) specifying VPC(s) to associate with a private hosted zone. Conflicts with the `delegationSetId` argument in this resource and any `route53.ZoneAssociation` resource specifying the same zone ID. Detailed below.
	Vpcs ZoneVpcArrayInput
	// The Hosted Zone ID. This can be referenced by zone records.
	ZoneId pulumi.StringPtrInput
}

func (ZoneState) ElementType 

func (ZoneState) ElementType() reflect.Type

type ZoneVpc 

type ZoneVpc struct {
	// ID of the VPC to associate.
	VpcId string `pulumi:"vpcId"`
	// Region of the VPC to associate. Defaults to AWS provider region.
	VpcRegion *string `pulumi:"vpcRegion"`
}

type ZoneVpcArgs 

type ZoneVpcArgs struct {
	// ID of the VPC to associate.
	VpcId pulumi.StringInput `pulumi:"vpcId"`
	// Region of the VPC to associate. Defaults to AWS provider region.
	VpcRegion pulumi.StringPtrInput `pulumi:"vpcRegion"`
}

func (ZoneVpcArgs) ElementType 

func (ZoneVpcArgs) ElementType() reflect.Type

func (ZoneVpcArgs) ToZoneVpcOutput 

func (i ZoneVpcArgs) ToZoneVpcOutput() ZoneVpcOutput

func (ZoneVpcArgs) ToZoneVpcOutputWithContext 

func (i ZoneVpcArgs) ToZoneVpcOutputWithContext(ctx context.Context) ZoneVpcOutput

type ZoneVpcArray 

type ZoneVpcArray []ZoneVpcInput

func (ZoneVpcArray) ElementType 

func (ZoneVpcArray) ElementType() reflect.Type

func (ZoneVpcArray) ToZoneVpcArrayOutput 

func (i ZoneVpcArray) ToZoneVpcArrayOutput() ZoneVpcArrayOutput

func (ZoneVpcArray) ToZoneVpcArrayOutputWithContext 

func (i ZoneVpcArray) ToZoneVpcArrayOutputWithContext(ctx context.Context) ZoneVpcArrayOutput

type ZoneVpcArrayInput 

type ZoneVpcArrayInput interface {
	pulumi.Input

	ToZoneVpcArrayOutput() ZoneVpcArrayOutput
	ToZoneVpcArrayOutputWithContext(context.Context) ZoneVpcArrayOutput
}

ZoneVpcArrayInput is an input type that accepts ZoneVpcArray and ZoneVpcArrayOutput values. You can construct a concrete instance of `ZoneVpcArrayInput` via: 

ZoneVpcArray{ ZoneVpcArgs{...} }

type ZoneVpcArrayOutput 

type ZoneVpcArrayOutput struct{ *pulumi.OutputState }

func (ZoneVpcArrayOutput) ElementType 

func (ZoneVpcArrayOutput) ElementType() reflect.Type

func (ZoneVpcArrayOutput) Index 

func (o ZoneVpcArrayOutput) Index(i pulumi.IntInput) ZoneVpcOutput

func (ZoneVpcArrayOutput) ToZoneVpcArrayOutput 

func (o ZoneVpcArrayOutput) ToZoneVpcArrayOutput() ZoneVpcArrayOutput

func (ZoneVpcArrayOutput) ToZoneVpcArrayOutputWithContext 

func (o ZoneVpcArrayOutput) ToZoneVpcArrayOutputWithContext(ctx context.Context) ZoneVpcArrayOutput

type ZoneVpcInput 

type ZoneVpcInput interface {
	pulumi.Input

	ToZoneVpcOutput() ZoneVpcOutput
	ToZoneVpcOutputWithContext(context.Context) ZoneVpcOutput
}

ZoneVpcInput is an input type that accepts ZoneVpcArgs and ZoneVpcOutput values. You can construct a concrete instance of `ZoneVpcInput` via: 

ZoneVpcArgs{...}

type ZoneVpcOutput 

type ZoneVpcOutput struct{ *pulumi.OutputState }

func (ZoneVpcOutput) ElementType 

func (ZoneVpcOutput) ElementType() reflect.Type

func (ZoneVpcOutput) ToZoneVpcOutput 

func (o ZoneVpcOutput) ToZoneVpcOutput() ZoneVpcOutput

func (ZoneVpcOutput) ToZoneVpcOutputWithContext 

func (o ZoneVpcOutput) ToZoneVpcOutputWithContext(ctx context.Context) ZoneVpcOutput

func (ZoneVpcOutput) VpcId 

func (o ZoneVpcOutput) VpcId() pulumi.StringOutput

ID of the VPC to associate.

func (ZoneVpcOutput) VpcRegion 

func (o ZoneVpcOutput) VpcRegion() pulumi.StringPtrOutput

Region of the VPC to associate. Defaults to AWS provider region.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.