route53

package
v4.17.0 Latest Latest
Warning

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

 Go to latest Published: Aug 20, 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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*DelegationSet) ElementType() reflect.Type

func (*DelegationSet) ToDelegationSetOutput 

func (i *DelegationSet) ToDelegationSetOutput() DelegationSetOutput

func (*DelegationSet) ToDelegationSetOutputWithContext 

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

func (*DelegationSet) ToDelegationSetPtrOutput 

func (i *DelegationSet) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (*DelegationSet) ToDelegationSetPtrOutputWithContext 

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 

type DelegationSetArray []DelegationSetInput

func (DelegationSetArray) ElementType 

func (DelegationSetArray) ElementType() reflect.Type

func (DelegationSetArray) ToDelegationSetArrayOutput 

func (i DelegationSetArray) ToDelegationSetArrayOutput() DelegationSetArrayOutput

func (DelegationSetArray) ToDelegationSetArrayOutputWithContext 

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

type DelegationSetArrayInput 

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 

type DelegationSetArrayOutput struct{ *pulumi.OutputState }

func (DelegationSetArrayOutput) ElementType 

func (DelegationSetArrayOutput) ElementType() reflect.Type

func (DelegationSetArrayOutput) Index 

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

func (DelegationSetArrayOutput) ToDelegationSetArrayOutput 

func (o DelegationSetArrayOutput) ToDelegationSetArrayOutput() DelegationSetArrayOutput

func (DelegationSetArrayOutput) ToDelegationSetArrayOutputWithContext 

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

type DelegationSetInput 

type DelegationSetInput interface {
	pulumi.Input

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

type DelegationSetMap 

type DelegationSetMap map[string]DelegationSetInput

func (DelegationSetMap) ElementType 

func (DelegationSetMap) ElementType() reflect.Type

func (DelegationSetMap) ToDelegationSetMapOutput 

func (i DelegationSetMap) ToDelegationSetMapOutput() DelegationSetMapOutput

func (DelegationSetMap) ToDelegationSetMapOutputWithContext 

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

type DelegationSetMapInput 

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 

type DelegationSetMapOutput struct{ *pulumi.OutputState }

func (DelegationSetMapOutput) ElementType 

func (DelegationSetMapOutput) ElementType() reflect.Type

func (DelegationSetMapOutput) MapIndex 

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

func (DelegationSetMapOutput) ToDelegationSetMapOutput 

func (o DelegationSetMapOutput) ToDelegationSetMapOutput() DelegationSetMapOutput

func (DelegationSetMapOutput) ToDelegationSetMapOutputWithContext 

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

type DelegationSetOutput 

type DelegationSetOutput struct{ *pulumi.OutputState }

func (DelegationSetOutput) ElementType 

func (DelegationSetOutput) ElementType() reflect.Type

func (DelegationSetOutput) ToDelegationSetOutput 

func (o DelegationSetOutput) ToDelegationSetOutput() DelegationSetOutput

func (DelegationSetOutput) ToDelegationSetOutputWithContext 

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

func (DelegationSetOutput) ToDelegationSetPtrOutput 

func (o DelegationSetOutput) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (DelegationSetOutput) ToDelegationSetPtrOutputWithContext 

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

type DelegationSetPtrInput 

type DelegationSetPtrInput interface {
	pulumi.Input

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

type DelegationSetPtrOutput 

type DelegationSetPtrOutput struct{ *pulumi.OutputState }

func (DelegationSetPtrOutput) Elem added in v4.15.0 

func (o DelegationSetPtrOutput) Elem() DelegationSetOutput

func (DelegationSetPtrOutput) ElementType 

func (DelegationSetPtrOutput) ElementType() reflect.Type

func (DelegationSetPtrOutput) ToDelegationSetPtrOutput 

func (o DelegationSetPtrOutput) ToDelegationSetPtrOutput() DelegationSetPtrOutput

func (DelegationSetPtrOutput) ToDelegationSetPtrOutputWithContext 

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 

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

type GetResolverEndpointFilterArgs 

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

func (GetResolverEndpointFilterArgs) ElementType 

func (GetResolverEndpointFilterArgs) ElementType() reflect.Type

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput 

func (i GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterArgs) ToGetResolverEndpointFilterOutputWithContext 

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

type GetResolverEndpointFilterArray 

type GetResolverEndpointFilterArray []GetResolverEndpointFilterInput

func (GetResolverEndpointFilterArray) ElementType 

func (GetResolverEndpointFilterArray) ElementType() reflect.Type

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput 

func (i GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArray) ToGetResolverEndpointFilterArrayOutputWithContext 

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

type GetResolverEndpointFilterArrayInput 

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 

type GetResolverEndpointFilterArrayOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterArrayOutput) ElementType 

func (GetResolverEndpointFilterArrayOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterArrayOutput) Index 

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

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput 

func (o GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutput() GetResolverEndpointFilterArrayOutput

func (GetResolverEndpointFilterArrayOutput) ToGetResolverEndpointFilterArrayOutputWithContext 

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

type GetResolverEndpointFilterInput 

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 

type GetResolverEndpointFilterOutput struct{ *pulumi.OutputState }

func (GetResolverEndpointFilterOutput) ElementType 

func (GetResolverEndpointFilterOutput) ElementType() reflect.Type

func (GetResolverEndpointFilterOutput) Name 

func (o GetResolverEndpointFilterOutput) Name() pulumi.StringOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput 

func (o GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutput() GetResolverEndpointFilterOutput

func (GetResolverEndpointFilterOutput) ToGetResolverEndpointFilterOutputWithContext 

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

func (GetResolverEndpointFilterOutput) Values 

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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// 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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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
	})
}

``` ### Aggregate Check

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "parent", &route53.HealthCheckArgs{
			Type:                 pulumi.String("CALCULATED"),
			ChildHealthThreshold: pulumi.Int(1),
			ChildHealthchecks: pulumi.StringArray{
				pulumi.Any(aws_route53_health_check.Child.Id),
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-test-calculated-health-check"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### CloudWatch Alarm Check

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*HealthCheck) ElementType() reflect.Type

func (*HealthCheck) ToHealthCheckOutput 

func (i *HealthCheck) ToHealthCheckOutput() HealthCheckOutput

func (*HealthCheck) ToHealthCheckOutputWithContext 

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

func (*HealthCheck) ToHealthCheckPtrOutput 

func (i *HealthCheck) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (*HealthCheck) ToHealthCheckPtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	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 

type HealthCheckArray []HealthCheckInput

func (HealthCheckArray) ElementType 

func (HealthCheckArray) ElementType() reflect.Type

func (HealthCheckArray) ToHealthCheckArrayOutput 

func (i HealthCheckArray) ToHealthCheckArrayOutput() HealthCheckArrayOutput

func (HealthCheckArray) ToHealthCheckArrayOutputWithContext 

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

type HealthCheckArrayInput 

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 

type HealthCheckArrayOutput struct{ *pulumi.OutputState }

func (HealthCheckArrayOutput) ElementType 

func (HealthCheckArrayOutput) ElementType() reflect.Type

func (HealthCheckArrayOutput) Index 

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

func (HealthCheckArrayOutput) ToHealthCheckArrayOutput 

func (o HealthCheckArrayOutput) ToHealthCheckArrayOutput() HealthCheckArrayOutput

func (HealthCheckArrayOutput) ToHealthCheckArrayOutputWithContext 

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

type HealthCheckInput 

type HealthCheckInput interface {
	pulumi.Input

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

type HealthCheckMap 

type HealthCheckMap map[string]HealthCheckInput

func (HealthCheckMap) ElementType 

func (HealthCheckMap) ElementType() reflect.Type

func (HealthCheckMap) ToHealthCheckMapOutput 

func (i HealthCheckMap) ToHealthCheckMapOutput() HealthCheckMapOutput

func (HealthCheckMap) ToHealthCheckMapOutputWithContext 

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

type HealthCheckMapInput 

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 

type HealthCheckMapOutput struct{ *pulumi.OutputState }

func (HealthCheckMapOutput) ElementType 

func (HealthCheckMapOutput) ElementType() reflect.Type

func (HealthCheckMapOutput) MapIndex 

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

func (HealthCheckMapOutput) ToHealthCheckMapOutput 

func (o HealthCheckMapOutput) ToHealthCheckMapOutput() HealthCheckMapOutput

func (HealthCheckMapOutput) ToHealthCheckMapOutputWithContext 

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

type HealthCheckOutput 

type HealthCheckOutput struct{ *pulumi.OutputState }

func (HealthCheckOutput) ElementType 

func (HealthCheckOutput) ElementType() reflect.Type

func (HealthCheckOutput) ToHealthCheckOutput 

func (o HealthCheckOutput) ToHealthCheckOutput() HealthCheckOutput

func (HealthCheckOutput) ToHealthCheckOutputWithContext 

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

func (HealthCheckOutput) ToHealthCheckPtrOutput 

func (o HealthCheckOutput) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (HealthCheckOutput) ToHealthCheckPtrOutputWithContext 

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

type HealthCheckPtrInput 

type HealthCheckPtrInput interface {
	pulumi.Input

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

type HealthCheckPtrOutput 

type HealthCheckPtrOutput struct{ *pulumi.OutputState }

func (HealthCheckPtrOutput) Elem added in v4.15.0 

func (o HealthCheckPtrOutput) Elem() HealthCheckOutput

func (HealthCheckPtrOutput) ElementType 

func (HealthCheckPtrOutput) ElementType() reflect.Type

func (HealthCheckPtrOutput) ToHealthCheckPtrOutput 

func (o HealthCheckPtrOutput) ToHealthCheckPtrOutput() HealthCheckPtrOutput

func (HealthCheckPtrOutput) ToHealthCheckPtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll 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 HostedZoneDnsSec 

type HostedZoneDnsSec struct {
	pulumi.CustomResourceState

	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringOutput `pulumi:"hostedZoneId"`
	// Hosted Zone signing status. Valid values: `SIGNING`, `NOT_SIGNING`. Defaults to `SIGNING`.
	SigningStatus pulumi.StringPtrOutput `pulumi:"signingStatus"`
}

Manages Route 53 Hosted Zone Domain Name System Security Extensions (DNSSEC). For more information about managing 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/v4/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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": "dnssec-route53.amazonaws.com",
					},
					"Sid":      "Allow Route 53 DNSSEC Service",
					"Resource": "*",
				},
				map[string]interface{}{
					"Action": "kms:CreateGrant",
					"Effect": "Allow",
					"Principal": map[string]interface{}{
						"Service": "dnssec-route53.amazonaws.com",
					},
					"Sid":      "Allow Route 53 DNSSEC Service to CreateGrant",
					"Resource": "*",
					"Condition": map[string]interface{}{
						"Bool": map[string]interface{}{
							"kms:GrantIsForAWSResource": "true",
						},
					},
				},
				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)
		exampleKey, 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
		}
		exampleZone, err := route53.NewZone(ctx, "exampleZone", nil)
		if err != nil {
			return err
		}
		exampleKeySigningKey, err := route53.NewKeySigningKey(ctx, "exampleKeySigningKey", &route53.KeySigningKeyArgs{
			HostedZoneId:            exampleZone.ID(),
			KeyManagementServiceArn: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = route53.NewHostedZoneDnsSec(ctx, "exampleHostedZoneDnsSec", &route53.HostedZoneDnsSecArgs{
			HostedZoneId: exampleKeySigningKey.HostedZoneId,
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleKeySigningKey,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

`aws_route53_hosted_zone_dnssec` resources can be imported by using the Route 53 Hosted Zone identifier, e.g.

```sh 

$ pulumi import aws:route53/hostedZoneDnsSec:HostedZoneDnsSec example Z1D633PJN98FT9

```

func GetHostedZoneDnsSec 

func GetHostedZoneDnsSec(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HostedZoneDnsSecState, opts ...pulumi.ResourceOption) (*HostedZoneDnsSec, error)

GetHostedZoneDnsSec gets an existing HostedZoneDnsSec 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 NewHostedZoneDnsSec 

func NewHostedZoneDnsSec(ctx *pulumi.Context,
	name string, args *HostedZoneDnsSecArgs, opts ...pulumi.ResourceOption) (*HostedZoneDnsSec, error)

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

func (*HostedZoneDnsSec) ElementType 

func (*HostedZoneDnsSec) ElementType() reflect.Type

func (*HostedZoneDnsSec) ToHostedZoneDnsSecOutput 

func (i *HostedZoneDnsSec) ToHostedZoneDnsSecOutput() HostedZoneDnsSecOutput

func (*HostedZoneDnsSec) ToHostedZoneDnsSecOutputWithContext 

func (i *HostedZoneDnsSec) ToHostedZoneDnsSecOutputWithContext(ctx context.Context) HostedZoneDnsSecOutput

func (*HostedZoneDnsSec) ToHostedZoneDnsSecPtrOutput 

func (i *HostedZoneDnsSec) ToHostedZoneDnsSecPtrOutput() HostedZoneDnsSecPtrOutput

func (*HostedZoneDnsSec) ToHostedZoneDnsSecPtrOutputWithContext 

func (i *HostedZoneDnsSec) ToHostedZoneDnsSecPtrOutputWithContext(ctx context.Context) HostedZoneDnsSecPtrOutput

type HostedZoneDnsSecArgs 

type HostedZoneDnsSecArgs struct {
	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringInput
	// Hosted Zone signing status. Valid values: `SIGNING`, `NOT_SIGNING`. Defaults to `SIGNING`.
	SigningStatus pulumi.StringPtrInput
}

The set of arguments for constructing a HostedZoneDnsSec resource.

func (HostedZoneDnsSecArgs) ElementType 

func (HostedZoneDnsSecArgs) ElementType() reflect.Type

type HostedZoneDnsSecArray 

type HostedZoneDnsSecArray []HostedZoneDnsSecInput

func (HostedZoneDnsSecArray) ElementType 

func (HostedZoneDnsSecArray) ElementType() reflect.Type

func (HostedZoneDnsSecArray) ToHostedZoneDnsSecArrayOutput 

func (i HostedZoneDnsSecArray) ToHostedZoneDnsSecArrayOutput() HostedZoneDnsSecArrayOutput

func (HostedZoneDnsSecArray) ToHostedZoneDnsSecArrayOutputWithContext 

func (i HostedZoneDnsSecArray) ToHostedZoneDnsSecArrayOutputWithContext(ctx context.Context) HostedZoneDnsSecArrayOutput

type HostedZoneDnsSecArrayInput 

type HostedZoneDnsSecArrayInput interface {
	pulumi.Input

	ToHostedZoneDnsSecArrayOutput() HostedZoneDnsSecArrayOutput
	ToHostedZoneDnsSecArrayOutputWithContext(context.Context) HostedZoneDnsSecArrayOutput
}

HostedZoneDnsSecArrayInput is an input type that accepts HostedZoneDnsSecArray and HostedZoneDnsSecArrayOutput values. You can construct a concrete instance of `HostedZoneDnsSecArrayInput` via: 

HostedZoneDnsSecArray{ HostedZoneDnsSecArgs{...} }

type HostedZoneDnsSecArrayOutput 

type HostedZoneDnsSecArrayOutput struct{ *pulumi.OutputState }

func (HostedZoneDnsSecArrayOutput) ElementType 

func (HostedZoneDnsSecArrayOutput) ElementType() reflect.Type

func (HostedZoneDnsSecArrayOutput) Index 

func (o HostedZoneDnsSecArrayOutput) Index(i pulumi.IntInput) HostedZoneDnsSecOutput

func (HostedZoneDnsSecArrayOutput) ToHostedZoneDnsSecArrayOutput 

func (o HostedZoneDnsSecArrayOutput) ToHostedZoneDnsSecArrayOutput() HostedZoneDnsSecArrayOutput

func (HostedZoneDnsSecArrayOutput) ToHostedZoneDnsSecArrayOutputWithContext 

func (o HostedZoneDnsSecArrayOutput) ToHostedZoneDnsSecArrayOutputWithContext(ctx context.Context) HostedZoneDnsSecArrayOutput

type HostedZoneDnsSecInput 

type HostedZoneDnsSecInput interface {
	pulumi.Input

	ToHostedZoneDnsSecOutput() HostedZoneDnsSecOutput
	ToHostedZoneDnsSecOutputWithContext(ctx context.Context) HostedZoneDnsSecOutput
}

type HostedZoneDnsSecMap 

type HostedZoneDnsSecMap map[string]HostedZoneDnsSecInput

func (HostedZoneDnsSecMap) ElementType 

func (HostedZoneDnsSecMap) ElementType() reflect.Type

func (HostedZoneDnsSecMap) ToHostedZoneDnsSecMapOutput 

func (i HostedZoneDnsSecMap) ToHostedZoneDnsSecMapOutput() HostedZoneDnsSecMapOutput

func (HostedZoneDnsSecMap) ToHostedZoneDnsSecMapOutputWithContext 

func (i HostedZoneDnsSecMap) ToHostedZoneDnsSecMapOutputWithContext(ctx context.Context) HostedZoneDnsSecMapOutput

type HostedZoneDnsSecMapInput 

type HostedZoneDnsSecMapInput interface {
	pulumi.Input

	ToHostedZoneDnsSecMapOutput() HostedZoneDnsSecMapOutput
	ToHostedZoneDnsSecMapOutputWithContext(context.Context) HostedZoneDnsSecMapOutput
}

HostedZoneDnsSecMapInput is an input type that accepts HostedZoneDnsSecMap and HostedZoneDnsSecMapOutput values. You can construct a concrete instance of `HostedZoneDnsSecMapInput` via: 

HostedZoneDnsSecMap{ "key": HostedZoneDnsSecArgs{...} }

type HostedZoneDnsSecMapOutput 

type HostedZoneDnsSecMapOutput struct{ *pulumi.OutputState }

func (HostedZoneDnsSecMapOutput) ElementType 

func (HostedZoneDnsSecMapOutput) ElementType() reflect.Type

func (HostedZoneDnsSecMapOutput) MapIndex 

func (o HostedZoneDnsSecMapOutput) MapIndex(k pulumi.StringInput) HostedZoneDnsSecOutput

func (HostedZoneDnsSecMapOutput) ToHostedZoneDnsSecMapOutput 

func (o HostedZoneDnsSecMapOutput) ToHostedZoneDnsSecMapOutput() HostedZoneDnsSecMapOutput

func (HostedZoneDnsSecMapOutput) ToHostedZoneDnsSecMapOutputWithContext 

func (o HostedZoneDnsSecMapOutput) ToHostedZoneDnsSecMapOutputWithContext(ctx context.Context) HostedZoneDnsSecMapOutput

type HostedZoneDnsSecOutput 

type HostedZoneDnsSecOutput struct{ *pulumi.OutputState }

func (HostedZoneDnsSecOutput) ElementType 

func (HostedZoneDnsSecOutput) ElementType() reflect.Type

func (HostedZoneDnsSecOutput) ToHostedZoneDnsSecOutput 

func (o HostedZoneDnsSecOutput) ToHostedZoneDnsSecOutput() HostedZoneDnsSecOutput

func (HostedZoneDnsSecOutput) ToHostedZoneDnsSecOutputWithContext 

func (o HostedZoneDnsSecOutput) ToHostedZoneDnsSecOutputWithContext(ctx context.Context) HostedZoneDnsSecOutput

func (HostedZoneDnsSecOutput) ToHostedZoneDnsSecPtrOutput 

func (o HostedZoneDnsSecOutput) ToHostedZoneDnsSecPtrOutput() HostedZoneDnsSecPtrOutput

func (HostedZoneDnsSecOutput) ToHostedZoneDnsSecPtrOutputWithContext 

func (o HostedZoneDnsSecOutput) ToHostedZoneDnsSecPtrOutputWithContext(ctx context.Context) HostedZoneDnsSecPtrOutput

type HostedZoneDnsSecPtrInput 

type HostedZoneDnsSecPtrInput interface {
	pulumi.Input

	ToHostedZoneDnsSecPtrOutput() HostedZoneDnsSecPtrOutput
	ToHostedZoneDnsSecPtrOutputWithContext(ctx context.Context) HostedZoneDnsSecPtrOutput
}

type HostedZoneDnsSecPtrOutput 

type HostedZoneDnsSecPtrOutput struct{ *pulumi.OutputState }

func (HostedZoneDnsSecPtrOutput) Elem added in v4.15.0 

func (o HostedZoneDnsSecPtrOutput) Elem() HostedZoneDnsSecOutput

func (HostedZoneDnsSecPtrOutput) ElementType 

func (HostedZoneDnsSecPtrOutput) ElementType() reflect.Type

func (HostedZoneDnsSecPtrOutput) ToHostedZoneDnsSecPtrOutput 

func (o HostedZoneDnsSecPtrOutput) ToHostedZoneDnsSecPtrOutput() HostedZoneDnsSecPtrOutput

func (HostedZoneDnsSecPtrOutput) ToHostedZoneDnsSecPtrOutputWithContext 

func (o HostedZoneDnsSecPtrOutput) ToHostedZoneDnsSecPtrOutputWithContext(ctx context.Context) HostedZoneDnsSecPtrOutput

type HostedZoneDnsSecState 

type HostedZoneDnsSecState struct {
	// Identifier of the Route 53 Hosted Zone.
	HostedZoneId pulumi.StringPtrInput
	// Hosted Zone signing status. Valid values: `SIGNING`, `NOT_SIGNING`. Defaults to `SIGNING`.
	SigningStatus pulumi.StringPtrInput
}

func (HostedZoneDnsSecState) ElementType 

func (HostedZoneDnsSecState) ElementType() reflect.Type

type KeySigningKey 

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 a Route 53 Key Signing Key. To manage Domain Name System Security Extensions (DNSSEC) for a Hosted Zone, see the `route53.HostedZoneDnsSec` resource. For more information about managing 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/v4/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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": "dnssec-route53.amazonaws.com",
					},
					"Sid":      "Allow Route 53 DNSSEC Service",
					"Resource": "*",
				},
				map[string]interface{}{
					"Action": "kms:CreateGrant",
					"Effect": "Allow",
					"Principal": map[string]interface{}{
						"Service": "dnssec-route53.amazonaws.com",
					},
					"Sid":      "Allow Route 53 DNSSEC Service to CreateGrant",
					"Resource": "*",
					"Condition": map[string]interface{}{
						"Bool": map[string]interface{}{
							"kms:GrantIsForAWSResource": "true",
						},
					},
				},
				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
		}
		exampleKeySigningKey, 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
		}
		_, err = route53.NewHostedZoneDnsSec(ctx, "exampleHostedZoneDnsSec", &route53.HostedZoneDnsSecArgs{
			HostedZoneId: exampleKeySigningKey.HostedZoneId,
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleKeySigningKey,
		}))
		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 

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 

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 

func (*KeySigningKey) ElementType() reflect.Type

func (*KeySigningKey) ToKeySigningKeyOutput 

func (i *KeySigningKey) ToKeySigningKeyOutput() KeySigningKeyOutput

func (*KeySigningKey) ToKeySigningKeyOutputWithContext 

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

func (*KeySigningKey) ToKeySigningKeyPtrOutput 

func (i *KeySigningKey) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (*KeySigningKey) ToKeySigningKeyPtrOutputWithContext 

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

type KeySigningKeyArgs 

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 

func (KeySigningKeyArgs) ElementType() reflect.Type

type KeySigningKeyArray 

type KeySigningKeyArray []KeySigningKeyInput

func (KeySigningKeyArray) ElementType 

func (KeySigningKeyArray) ElementType() reflect.Type

func (KeySigningKeyArray) ToKeySigningKeyArrayOutput 

func (i KeySigningKeyArray) ToKeySigningKeyArrayOutput() KeySigningKeyArrayOutput

func (KeySigningKeyArray) ToKeySigningKeyArrayOutputWithContext 

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

type KeySigningKeyArrayInput 

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 

type KeySigningKeyArrayOutput struct{ *pulumi.OutputState }

func (KeySigningKeyArrayOutput) ElementType 

func (KeySigningKeyArrayOutput) ElementType() reflect.Type

func (KeySigningKeyArrayOutput) Index 

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

func (KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutput 

func (o KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutput() KeySigningKeyArrayOutput

func (KeySigningKeyArrayOutput) ToKeySigningKeyArrayOutputWithContext 

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

type KeySigningKeyInput 

type KeySigningKeyInput interface {
	pulumi.Input

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

type KeySigningKeyMap 

type KeySigningKeyMap map[string]KeySigningKeyInput

func (KeySigningKeyMap) ElementType 

func (KeySigningKeyMap) ElementType() reflect.Type

func (KeySigningKeyMap) ToKeySigningKeyMapOutput 

func (i KeySigningKeyMap) ToKeySigningKeyMapOutput() KeySigningKeyMapOutput

func (KeySigningKeyMap) ToKeySigningKeyMapOutputWithContext 

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

type KeySigningKeyMapInput 

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 

type KeySigningKeyMapOutput struct{ *pulumi.OutputState }

func (KeySigningKeyMapOutput) ElementType 

func (KeySigningKeyMapOutput) ElementType() reflect.Type

func (KeySigningKeyMapOutput) MapIndex 

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

func (KeySigningKeyMapOutput) ToKeySigningKeyMapOutput 

func (o KeySigningKeyMapOutput) ToKeySigningKeyMapOutput() KeySigningKeyMapOutput

func (KeySigningKeyMapOutput) ToKeySigningKeyMapOutputWithContext 

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

type KeySigningKeyOutput 

type KeySigningKeyOutput struct{ *pulumi.OutputState }

func (KeySigningKeyOutput) ElementType 

func (KeySigningKeyOutput) ElementType() reflect.Type

func (KeySigningKeyOutput) ToKeySigningKeyOutput 

func (o KeySigningKeyOutput) ToKeySigningKeyOutput() KeySigningKeyOutput

func (KeySigningKeyOutput) ToKeySigningKeyOutputWithContext 

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

func (KeySigningKeyOutput) ToKeySigningKeyPtrOutput 

func (o KeySigningKeyOutput) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (KeySigningKeyOutput) ToKeySigningKeyPtrOutputWithContext 

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

type KeySigningKeyPtrInput 

type KeySigningKeyPtrInput interface {
	pulumi.Input

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

type KeySigningKeyPtrOutput 

type KeySigningKeyPtrOutput struct{ *pulumi.OutputState }

func (KeySigningKeyPtrOutput) Elem added in v4.15.0 

func (o KeySigningKeyPtrOutput) Elem() KeySigningKeyOutput

func (KeySigningKeyPtrOutput) ElementType 

func (KeySigningKeyPtrOutput) ElementType() reflect.Type

func (KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutput 

func (o KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutput() KeySigningKeyPtrOutput

func (KeySigningKeyPtrOutput) ToKeySigningKeyPtrOutputWithContext 

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

type KeySigningKeyState 

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 

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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "us_east_1", &providers.awsArgs{
			Region: "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 

func (*QueryLog) ElementType() reflect.Type

func (*QueryLog) ToQueryLogOutput 

func (i *QueryLog) ToQueryLogOutput() QueryLogOutput

func (*QueryLog) ToQueryLogOutputWithContext 

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

func (*QueryLog) ToQueryLogPtrOutput 

func (i *QueryLog) ToQueryLogPtrOutput() QueryLogPtrOutput

func (*QueryLog) ToQueryLogPtrOutputWithContext 

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 

type QueryLogArray []QueryLogInput

func (QueryLogArray) ElementType 

func (QueryLogArray) ElementType() reflect.Type

func (QueryLogArray) ToQueryLogArrayOutput 

func (i QueryLogArray) ToQueryLogArrayOutput() QueryLogArrayOutput

func (QueryLogArray) ToQueryLogArrayOutputWithContext 

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

type QueryLogArrayInput 

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 

type QueryLogArrayOutput struct{ *pulumi.OutputState }

func (QueryLogArrayOutput) ElementType 

func (QueryLogArrayOutput) ElementType() reflect.Type

func (QueryLogArrayOutput) Index 

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

func (QueryLogArrayOutput) ToQueryLogArrayOutput 

func (o QueryLogArrayOutput) ToQueryLogArrayOutput() QueryLogArrayOutput

func (QueryLogArrayOutput) ToQueryLogArrayOutputWithContext 

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

type QueryLogInput 

type QueryLogInput interface {
	pulumi.Input

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

type QueryLogMap 

type QueryLogMap map[string]QueryLogInput

func (QueryLogMap) ElementType 

func (QueryLogMap) ElementType() reflect.Type

func (QueryLogMap) ToQueryLogMapOutput 

func (i QueryLogMap) ToQueryLogMapOutput() QueryLogMapOutput

func (QueryLogMap) ToQueryLogMapOutputWithContext 

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

type QueryLogMapInput 

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 

type QueryLogMapOutput struct{ *pulumi.OutputState }

func (QueryLogMapOutput) ElementType 

func (QueryLogMapOutput) ElementType() reflect.Type

func (QueryLogMapOutput) MapIndex 

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

func (QueryLogMapOutput) ToQueryLogMapOutput 

func (o QueryLogMapOutput) ToQueryLogMapOutput() QueryLogMapOutput

func (QueryLogMapOutput) ToQueryLogMapOutputWithContext 

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

type QueryLogOutput 

type QueryLogOutput struct{ *pulumi.OutputState }

func (QueryLogOutput) ElementType 

func (QueryLogOutput) ElementType() reflect.Type

func (QueryLogOutput) ToQueryLogOutput 

func (o QueryLogOutput) ToQueryLogOutput() QueryLogOutput

func (QueryLogOutput) ToQueryLogOutputWithContext 

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

func (QueryLogOutput) ToQueryLogPtrOutput 

func (o QueryLogOutput) ToQueryLogPtrOutput() QueryLogPtrOutput

func (QueryLogOutput) ToQueryLogPtrOutputWithContext 

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

type QueryLogPtrInput 

type QueryLogPtrInput interface {
	pulumi.Input

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

type QueryLogPtrOutput 

type QueryLogPtrOutput struct{ *pulumi.OutputState }

func (QueryLogPtrOutput) Elem added in v4.15.0 

func (o QueryLogPtrOutput) Elem() QueryLogOutput

func (QueryLogPtrOutput) ElementType 

func (QueryLogPtrOutput) ElementType() reflect.Type

func (QueryLogPtrOutput) ToQueryLogPtrOutput 

func (o QueryLogPtrOutput) ToQueryLogPtrOutput() QueryLogPtrOutput

func (QueryLogPtrOutput) ToQueryLogPtrOutputWithContext 

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 ### Simple routing policy

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewRecord(ctx, "www", &route53.RecordArgs{
			ZoneId: pulumi.Any(aws_route53_zone.Primary.Zone_id),
			Name:   pulumi.String("www.example.com"),
			Type:   pulumi.String("A"),
			Ttl:    pulumi.Int(300),
			Records: pulumi.StringArray{
				pulumi.Any(aws_eip.Lb.Public_ip),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### 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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/elb"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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(172800),
			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 

func (*Record) ElementType() reflect.Type

func (*Record) ToRecordOutput 

func (i *Record) ToRecordOutput() RecordOutput

func (*Record) ToRecordOutputWithContext 

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

func (*Record) ToRecordPtrOutput 

func (i *Record) ToRecordPtrOutput() RecordPtrOutput

func (*Record) ToRecordPtrOutputWithContext 

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 

type RecordArray []RecordInput

func (RecordArray) ElementType 

func (RecordArray) ElementType() reflect.Type

func (RecordArray) ToRecordArrayOutput 

func (i RecordArray) ToRecordArrayOutput() RecordArrayOutput

func (RecordArray) ToRecordArrayOutputWithContext 

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

type RecordArrayInput 

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 

type RecordArrayOutput struct{ *pulumi.OutputState }

func (RecordArrayOutput) ElementType 

func (RecordArrayOutput) ElementType() reflect.Type

func (RecordArrayOutput) Index 

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

func (RecordArrayOutput) ToRecordArrayOutput 

func (o RecordArrayOutput) ToRecordArrayOutput() RecordArrayOutput

func (RecordArrayOutput) ToRecordArrayOutputWithContext 

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 

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 

type RecordMap map[string]RecordInput

func (RecordMap) ElementType 

func (RecordMap) ElementType() reflect.Type

func (RecordMap) ToRecordMapOutput 

func (i RecordMap) ToRecordMapOutput() RecordMapOutput

func (RecordMap) ToRecordMapOutputWithContext 

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

type RecordMapInput 

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 

type RecordMapOutput struct{ *pulumi.OutputState }

func (RecordMapOutput) ElementType 

func (RecordMapOutput) ElementType() reflect.Type

func (RecordMapOutput) MapIndex 

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

func (RecordMapOutput) ToRecordMapOutput 

func (o RecordMapOutput) ToRecordMapOutput() RecordMapOutput

func (RecordMapOutput) ToRecordMapOutputWithContext 

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

type RecordOutput 

type RecordOutput struct{ *pulumi.OutputState }

func (RecordOutput) ElementType 

func (RecordOutput) ElementType() reflect.Type

func (RecordOutput) ToRecordOutput 

func (o RecordOutput) ToRecordOutput() RecordOutput

func (RecordOutput) ToRecordOutputWithContext 

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

func (RecordOutput) ToRecordPtrOutput 

func (o RecordOutput) ToRecordPtrOutput() RecordPtrOutput

func (RecordOutput) ToRecordPtrOutputWithContext 

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

type RecordPtrInput 

type RecordPtrInput interface {
	pulumi.Input

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

type RecordPtrOutput 

type RecordPtrOutput struct{ *pulumi.OutputState }

func (RecordPtrOutput) Elem added in v4.15.0 

func (o RecordPtrOutput) Elem() RecordOutput

func (RecordPtrOutput) ElementType 

func (RecordPtrOutput) ElementType() reflect.Type

func (RecordPtrOutput) ToRecordPtrOutput 

func (o RecordPtrOutput) ToRecordPtrOutput() RecordPtrOutput

func (RecordPtrOutput) ToRecordPtrOutputWithContext 

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 

type RecordType string

func (RecordType) ElementType 

func (RecordType) ElementType() reflect.Type

func (RecordType) ToRecordTypeOutput added in v4.13.0 

func (e RecordType) ToRecordTypeOutput() RecordTypeOutput

func (RecordType) ToRecordTypeOutputWithContext added in v4.13.0 

func (e RecordType) ToRecordTypeOutputWithContext(ctx context.Context) RecordTypeOutput

func (RecordType) ToRecordTypePtrOutput added in v4.13.0 

func (e RecordType) ToRecordTypePtrOutput() RecordTypePtrOutput

func (RecordType) ToRecordTypePtrOutputWithContext added in v4.13.0 

func (e RecordType) ToRecordTypePtrOutputWithContext(ctx context.Context) RecordTypePtrOutput

func (RecordType) ToStringOutput 

func (e RecordType) ToStringOutput() pulumi.StringOutput

func (RecordType) ToStringOutputWithContext 

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

func (RecordType) ToStringPtrOutput 

func (e RecordType) ToStringPtrOutput() pulumi.StringPtrOutput

func (RecordType) ToStringPtrOutputWithContext 

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

type RecordTypeInput added in v4.13.0 

type RecordTypeInput interface {
	pulumi.Input

	ToRecordTypeOutput() RecordTypeOutput
	ToRecordTypeOutputWithContext(context.Context) RecordTypeOutput
}

RecordTypeInput is an input type that accepts RecordTypeArgs and RecordTypeOutput values. You can construct a concrete instance of `RecordTypeInput` via: 

RecordTypeArgs{...}

type RecordTypeOutput added in v4.13.0 

type RecordTypeOutput struct{ *pulumi.OutputState }

func (RecordTypeOutput) ElementType added in v4.13.0 

func (RecordTypeOutput) ElementType() reflect.Type

func (RecordTypeOutput) ToRecordTypeOutput added in v4.13.0 

func (o RecordTypeOutput) ToRecordTypeOutput() RecordTypeOutput

func (RecordTypeOutput) ToRecordTypeOutputWithContext added in v4.13.0 

func (o RecordTypeOutput) ToRecordTypeOutputWithContext(ctx context.Context) RecordTypeOutput

func (RecordTypeOutput) ToRecordTypePtrOutput added in v4.13.0 

func (o RecordTypeOutput) ToRecordTypePtrOutput() RecordTypePtrOutput

func (RecordTypeOutput) ToRecordTypePtrOutputWithContext added in v4.13.0 

func (o RecordTypeOutput) ToRecordTypePtrOutputWithContext(ctx context.Context) RecordTypePtrOutput

func (RecordTypeOutput) ToStringOutput added in v4.13.0 

func (o RecordTypeOutput) ToStringOutput() pulumi.StringOutput

func (RecordTypeOutput) ToStringOutputWithContext added in v4.13.0 

func (o RecordTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (RecordTypeOutput) ToStringPtrOutput added in v4.13.0 

func (o RecordTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RecordTypeOutput) ToStringPtrOutputWithContext added in v4.13.0 

func (o RecordTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type RecordTypePtrInput added in v4.13.0 

type RecordTypePtrInput interface {
	pulumi.Input

	ToRecordTypePtrOutput() RecordTypePtrOutput
	ToRecordTypePtrOutputWithContext(context.Context) RecordTypePtrOutput
}

func RecordTypePtr added in v4.13.0 

func RecordTypePtr(v string) RecordTypePtrInput

type RecordTypePtrOutput added in v4.13.0 

type RecordTypePtrOutput struct{ *pulumi.OutputState }

func (RecordTypePtrOutput) Elem added in v4.13.0 

func (o RecordTypePtrOutput) Elem() RecordTypeOutput

func (RecordTypePtrOutput) ElementType added in v4.13.0 

func (RecordTypePtrOutput) ElementType() reflect.Type

func (RecordTypePtrOutput) ToRecordTypePtrOutput added in v4.13.0 

func (o RecordTypePtrOutput) ToRecordTypePtrOutput() RecordTypePtrOutput

func (RecordTypePtrOutput) ToRecordTypePtrOutputWithContext added in v4.13.0 

func (o RecordTypePtrOutput) ToRecordTypePtrOutputWithContext(ctx context.Context) RecordTypePtrOutput

func (RecordTypePtrOutput) ToStringPtrOutput added in v4.13.0 

func (o RecordTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (RecordTypePtrOutput) ToStringPtrOutputWithContext added in v4.13.0 

func (o RecordTypePtrOutput) 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 

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/v4/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

func (*ResolverDnsSecConfig) ElementType() reflect.Type

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigOutput 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigOutput() ResolverDnsSecConfigOutput

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigOutputWithContext 

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

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutput 

func (i *ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (*ResolverDnsSecConfig) ToResolverDnsSecConfigPtrOutputWithContext 

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

type ResolverDnsSecConfigArgs 

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 

func (ResolverDnsSecConfigArgs) ElementType() reflect.Type

type ResolverDnsSecConfigArray 

type ResolverDnsSecConfigArray []ResolverDnsSecConfigInput

func (ResolverDnsSecConfigArray) ElementType 

func (ResolverDnsSecConfigArray) ElementType() reflect.Type

func (ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutput 

func (i ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutput() ResolverDnsSecConfigArrayOutput

func (ResolverDnsSecConfigArray) ToResolverDnsSecConfigArrayOutputWithContext 

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

type ResolverDnsSecConfigArrayInput 

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 

type ResolverDnsSecConfigArrayOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigArrayOutput) ElementType 

func (ResolverDnsSecConfigArrayOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigArrayOutput) Index 

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

func (ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutput 

func (o ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutput() ResolverDnsSecConfigArrayOutput

func (ResolverDnsSecConfigArrayOutput) ToResolverDnsSecConfigArrayOutputWithContext 

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

type ResolverDnsSecConfigInput 

type ResolverDnsSecConfigInput interface {
	pulumi.Input

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

type ResolverDnsSecConfigMap 

type ResolverDnsSecConfigMap map[string]ResolverDnsSecConfigInput

func (ResolverDnsSecConfigMap) ElementType 

func (ResolverDnsSecConfigMap) ElementType() reflect.Type

func (ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutput 

func (i ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutput() ResolverDnsSecConfigMapOutput

func (ResolverDnsSecConfigMap) ToResolverDnsSecConfigMapOutputWithContext 

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

type ResolverDnsSecConfigMapInput 

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 

type ResolverDnsSecConfigMapOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigMapOutput) ElementType 

func (ResolverDnsSecConfigMapOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigMapOutput) MapIndex 

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

func (ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutput 

func (o ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutput() ResolverDnsSecConfigMapOutput

func (ResolverDnsSecConfigMapOutput) ToResolverDnsSecConfigMapOutputWithContext 

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

type ResolverDnsSecConfigOutput 

type ResolverDnsSecConfigOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigOutput) ElementType 

func (ResolverDnsSecConfigOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutput 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutput() ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigOutputWithContext 

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

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutput 

func (o ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (ResolverDnsSecConfigOutput) ToResolverDnsSecConfigPtrOutputWithContext 

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

type ResolverDnsSecConfigPtrInput 

type ResolverDnsSecConfigPtrInput interface {
	pulumi.Input

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

type ResolverDnsSecConfigPtrOutput 

type ResolverDnsSecConfigPtrOutput struct{ *pulumi.OutputState }

func (ResolverDnsSecConfigPtrOutput) Elem added in v4.15.0 

func (o ResolverDnsSecConfigPtrOutput) Elem() ResolverDnsSecConfigOutput

func (ResolverDnsSecConfigPtrOutput) ElementType 

func (ResolverDnsSecConfigPtrOutput) ElementType() reflect.Type

func (ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutput 

func (o ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutput() ResolverDnsSecConfigPtrOutput

func (ResolverDnsSecConfigPtrOutput) ToResolverDnsSecConfigPtrOutputWithContext 

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

type ResolverDnsSecConfigState 

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 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Route 53 Resolver endpoint resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*ResolverEndpoint) ElementType() reflect.Type

func (*ResolverEndpoint) ToResolverEndpointOutput 

func (i *ResolverEndpoint) ToResolverEndpointOutput() ResolverEndpointOutput

func (*ResolverEndpoint) ToResolverEndpointOutputWithContext 

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

func (*ResolverEndpoint) ToResolverEndpointPtrOutput 

func (i *ResolverEndpoint) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (*ResolverEndpoint) ToResolverEndpointPtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverEndpoint resource.

func (ResolverEndpointArgs) ElementType 

func (ResolverEndpointArgs) ElementType() reflect.Type

type ResolverEndpointArray 

type ResolverEndpointArray []ResolverEndpointInput

func (ResolverEndpointArray) ElementType 

func (ResolverEndpointArray) ElementType() reflect.Type

func (ResolverEndpointArray) ToResolverEndpointArrayOutput 

func (i ResolverEndpointArray) ToResolverEndpointArrayOutput() ResolverEndpointArrayOutput

func (ResolverEndpointArray) ToResolverEndpointArrayOutputWithContext 

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

type ResolverEndpointArrayInput 

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 

type ResolverEndpointArrayOutput struct{ *pulumi.OutputState }

func (ResolverEndpointArrayOutput) ElementType 

func (ResolverEndpointArrayOutput) ElementType() reflect.Type

func (ResolverEndpointArrayOutput) Index 

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

func (ResolverEndpointArrayOutput) ToResolverEndpointArrayOutput 

func (o ResolverEndpointArrayOutput) ToResolverEndpointArrayOutput() ResolverEndpointArrayOutput

func (ResolverEndpointArrayOutput) ToResolverEndpointArrayOutputWithContext 

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

type ResolverEndpointInput 

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 

type ResolverEndpointMap map[string]ResolverEndpointInput

func (ResolverEndpointMap) ElementType 

func (ResolverEndpointMap) ElementType() reflect.Type

func (ResolverEndpointMap) ToResolverEndpointMapOutput 

func (i ResolverEndpointMap) ToResolverEndpointMapOutput() ResolverEndpointMapOutput

func (ResolverEndpointMap) ToResolverEndpointMapOutputWithContext 

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

type ResolverEndpointMapInput 

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 

type ResolverEndpointMapOutput struct{ *pulumi.OutputState }

func (ResolverEndpointMapOutput) ElementType 

func (ResolverEndpointMapOutput) ElementType() reflect.Type

func (ResolverEndpointMapOutput) MapIndex 

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

func (ResolverEndpointMapOutput) ToResolverEndpointMapOutput 

func (o ResolverEndpointMapOutput) ToResolverEndpointMapOutput() ResolverEndpointMapOutput

func (ResolverEndpointMapOutput) ToResolverEndpointMapOutputWithContext 

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

type ResolverEndpointOutput 

type ResolverEndpointOutput struct{ *pulumi.OutputState }

func (ResolverEndpointOutput) ElementType 

func (ResolverEndpointOutput) ElementType() reflect.Type

func (ResolverEndpointOutput) ToResolverEndpointOutput 

func (o ResolverEndpointOutput) ToResolverEndpointOutput() ResolverEndpointOutput

func (ResolverEndpointOutput) ToResolverEndpointOutputWithContext 

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

func (ResolverEndpointOutput) ToResolverEndpointPtrOutput 

func (o ResolverEndpointOutput) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (ResolverEndpointOutput) ToResolverEndpointPtrOutputWithContext 

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

type ResolverEndpointPtrInput 

type ResolverEndpointPtrInput interface {
	pulumi.Input

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

type ResolverEndpointPtrOutput 

type ResolverEndpointPtrOutput struct{ *pulumi.OutputState }

func (ResolverEndpointPtrOutput) Elem added in v4.15.0 

func (o ResolverEndpointPtrOutput) Elem() ResolverEndpointOutput

func (ResolverEndpointPtrOutput) ElementType 

func (ResolverEndpointPtrOutput) ElementType() reflect.Type

func (ResolverEndpointPtrOutput) ToResolverEndpointPtrOutput 

func (o ResolverEndpointPtrOutput) ToResolverEndpointPtrOutput() ResolverEndpointPtrOutput

func (ResolverEndpointPtrOutput) ToResolverEndpointPtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (ResolverEndpointState) ElementType 

func (ResolverEndpointState) ElementType() reflect.Type

type ResolverFirewallConfig added in v4.9.0 

type ResolverFirewallConfig struct {
	pulumi.CustomResourceState

	// Determines how Route 53 Resolver handles queries during failures, for example when all traffic that is sent to DNS Firewall fails to receive a reply. By default, fail open is disabled, which means the failure mode is closed. This approach favors security over availability. DNS Firewall blocks queries that it is unable to evaluate properly. If you enable this option, the failure mode is open. This approach favors availability over security. DNS Firewall allows queries to proceed if it is unable to properly evaluate them. Valid values: `ENABLED`, `DISABLED`.
	FirewallFailOpen pulumi.StringOutput `pulumi:"firewallFailOpen"`
	// The AWS account ID of the owner of the VPC that this firewall configuration applies to.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// The ID of the VPC that the configuration is for.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
}

Provides a Route 53 Resolver DNS Firewall config resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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.NewResolverFirewallConfig(ctx, "exampleResolverFirewallConfig", &route53.ResolverFirewallConfigArgs{
			ResourceId:       exampleVpc.ID(),
			FirewallFailOpen: pulumi.String("ENABLED"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

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

```sh 

$ pulumi import aws:route53/resolverFirewallConfig:ResolverFirewallConfig example rdsc-be1866ecc1683e95

```

func GetResolverFirewallConfig added in v4.9.0 

func GetResolverFirewallConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverFirewallConfigState, opts ...pulumi.ResourceOption) (*ResolverFirewallConfig, error)

GetResolverFirewallConfig gets an existing ResolverFirewallConfig 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 NewResolverFirewallConfig added in v4.9.0 

func NewResolverFirewallConfig(ctx *pulumi.Context,
	name string, args *ResolverFirewallConfigArgs, opts ...pulumi.ResourceOption) (*ResolverFirewallConfig, error)

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

func (*ResolverFirewallConfig) ElementType added in v4.9.0 

func (*ResolverFirewallConfig) ElementType() reflect.Type

func (*ResolverFirewallConfig) ToResolverFirewallConfigOutput added in v4.9.0 

func (i *ResolverFirewallConfig) ToResolverFirewallConfigOutput() ResolverFirewallConfigOutput

func (*ResolverFirewallConfig) ToResolverFirewallConfigOutputWithContext added in v4.9.0 

func (i *ResolverFirewallConfig) ToResolverFirewallConfigOutputWithContext(ctx context.Context) ResolverFirewallConfigOutput

func (*ResolverFirewallConfig) ToResolverFirewallConfigPtrOutput added in v4.9.0 

func (i *ResolverFirewallConfig) ToResolverFirewallConfigPtrOutput() ResolverFirewallConfigPtrOutput

func (*ResolverFirewallConfig) ToResolverFirewallConfigPtrOutputWithContext added in v4.9.0 

func (i *ResolverFirewallConfig) ToResolverFirewallConfigPtrOutputWithContext(ctx context.Context) ResolverFirewallConfigPtrOutput

type ResolverFirewallConfigArgs added in v4.9.0 

type ResolverFirewallConfigArgs struct {
	// Determines how Route 53 Resolver handles queries during failures, for example when all traffic that is sent to DNS Firewall fails to receive a reply. By default, fail open is disabled, which means the failure mode is closed. This approach favors security over availability. DNS Firewall blocks queries that it is unable to evaluate properly. If you enable this option, the failure mode is open. This approach favors availability over security. DNS Firewall allows queries to proceed if it is unable to properly evaluate them. Valid values: `ENABLED`, `DISABLED`.
	FirewallFailOpen pulumi.StringPtrInput
	// The ID of the VPC that the configuration is for.
	ResourceId pulumi.StringInput
}

The set of arguments for constructing a ResolverFirewallConfig resource.

func (ResolverFirewallConfigArgs) ElementType added in v4.9.0 

func (ResolverFirewallConfigArgs) ElementType() reflect.Type

type ResolverFirewallConfigArray added in v4.9.0 

type ResolverFirewallConfigArray []ResolverFirewallConfigInput

func (ResolverFirewallConfigArray) ElementType added in v4.9.0 

func (ResolverFirewallConfigArray) ElementType() reflect.Type

func (ResolverFirewallConfigArray) ToResolverFirewallConfigArrayOutput added in v4.9.0 

func (i ResolverFirewallConfigArray) ToResolverFirewallConfigArrayOutput() ResolverFirewallConfigArrayOutput

func (ResolverFirewallConfigArray) ToResolverFirewallConfigArrayOutputWithContext added in v4.9.0 

func (i ResolverFirewallConfigArray) ToResolverFirewallConfigArrayOutputWithContext(ctx context.Context) ResolverFirewallConfigArrayOutput

type ResolverFirewallConfigArrayInput added in v4.9.0 

type ResolverFirewallConfigArrayInput interface {
	pulumi.Input

	ToResolverFirewallConfigArrayOutput() ResolverFirewallConfigArrayOutput
	ToResolverFirewallConfigArrayOutputWithContext(context.Context) ResolverFirewallConfigArrayOutput
}

ResolverFirewallConfigArrayInput is an input type that accepts ResolverFirewallConfigArray and ResolverFirewallConfigArrayOutput values. You can construct a concrete instance of `ResolverFirewallConfigArrayInput` via: 

ResolverFirewallConfigArray{ ResolverFirewallConfigArgs{...} }

type ResolverFirewallConfigArrayOutput added in v4.9.0 

type ResolverFirewallConfigArrayOutput struct{ *pulumi.OutputState }

func (ResolverFirewallConfigArrayOutput) ElementType added in v4.9.0 

func (ResolverFirewallConfigArrayOutput) ElementType() reflect.Type

func (ResolverFirewallConfigArrayOutput) Index added in v4.9.0 

func (o ResolverFirewallConfigArrayOutput) Index(i pulumi.IntInput) ResolverFirewallConfigOutput

func (ResolverFirewallConfigArrayOutput) ToResolverFirewallConfigArrayOutput added in v4.9.0 

func (o ResolverFirewallConfigArrayOutput) ToResolverFirewallConfigArrayOutput() ResolverFirewallConfigArrayOutput

func (ResolverFirewallConfigArrayOutput) ToResolverFirewallConfigArrayOutputWithContext added in v4.9.0 

func (o ResolverFirewallConfigArrayOutput) ToResolverFirewallConfigArrayOutputWithContext(ctx context.Context) ResolverFirewallConfigArrayOutput

type ResolverFirewallConfigInput added in v4.9.0 

type ResolverFirewallConfigInput interface {
	pulumi.Input

	ToResolverFirewallConfigOutput() ResolverFirewallConfigOutput
	ToResolverFirewallConfigOutputWithContext(ctx context.Context) ResolverFirewallConfigOutput
}

type ResolverFirewallConfigMap added in v4.9.0 

type ResolverFirewallConfigMap map[string]ResolverFirewallConfigInput

func (ResolverFirewallConfigMap) ElementType added in v4.9.0 

func (ResolverFirewallConfigMap) ElementType() reflect.Type

func (ResolverFirewallConfigMap) ToResolverFirewallConfigMapOutput added in v4.9.0 

func (i ResolverFirewallConfigMap) ToResolverFirewallConfigMapOutput() ResolverFirewallConfigMapOutput

func (ResolverFirewallConfigMap) ToResolverFirewallConfigMapOutputWithContext added in v4.9.0 

func (i ResolverFirewallConfigMap) ToResolverFirewallConfigMapOutputWithContext(ctx context.Context) ResolverFirewallConfigMapOutput

type ResolverFirewallConfigMapInput added in v4.9.0 

type ResolverFirewallConfigMapInput interface {
	pulumi.Input

	ToResolverFirewallConfigMapOutput() ResolverFirewallConfigMapOutput
	ToResolverFirewallConfigMapOutputWithContext(context.Context) ResolverFirewallConfigMapOutput
}

ResolverFirewallConfigMapInput is an input type that accepts ResolverFirewallConfigMap and ResolverFirewallConfigMapOutput values. You can construct a concrete instance of `ResolverFirewallConfigMapInput` via: 

ResolverFirewallConfigMap{ "key": ResolverFirewallConfigArgs{...} }

type ResolverFirewallConfigMapOutput added in v4.9.0 

type ResolverFirewallConfigMapOutput struct{ *pulumi.OutputState }

func (ResolverFirewallConfigMapOutput) ElementType added in v4.9.0 

func (ResolverFirewallConfigMapOutput) ElementType() reflect.Type

func (ResolverFirewallConfigMapOutput) MapIndex added in v4.9.0 

func (o ResolverFirewallConfigMapOutput) MapIndex(k pulumi.StringInput) ResolverFirewallConfigOutput

func (ResolverFirewallConfigMapOutput) ToResolverFirewallConfigMapOutput added in v4.9.0 

func (o ResolverFirewallConfigMapOutput) ToResolverFirewallConfigMapOutput() ResolverFirewallConfigMapOutput

func (ResolverFirewallConfigMapOutput) ToResolverFirewallConfigMapOutputWithContext added in v4.9.0 

func (o ResolverFirewallConfigMapOutput) ToResolverFirewallConfigMapOutputWithContext(ctx context.Context) ResolverFirewallConfigMapOutput

type ResolverFirewallConfigOutput added in v4.9.0 

type ResolverFirewallConfigOutput struct{ *pulumi.OutputState }

func (ResolverFirewallConfigOutput) ElementType added in v4.9.0 

func (ResolverFirewallConfigOutput) ElementType() reflect.Type

func (ResolverFirewallConfigOutput) ToResolverFirewallConfigOutput added in v4.9.0 

func (o ResolverFirewallConfigOutput) ToResolverFirewallConfigOutput() ResolverFirewallConfigOutput

func (ResolverFirewallConfigOutput) ToResolverFirewallConfigOutputWithContext added in v4.9.0 

func (o ResolverFirewallConfigOutput) ToResolverFirewallConfigOutputWithContext(ctx context.Context) ResolverFirewallConfigOutput

func (ResolverFirewallConfigOutput) ToResolverFirewallConfigPtrOutput added in v4.9.0 

func (o ResolverFirewallConfigOutput) ToResolverFirewallConfigPtrOutput() ResolverFirewallConfigPtrOutput

func (ResolverFirewallConfigOutput) ToResolverFirewallConfigPtrOutputWithContext added in v4.9.0 

func (o ResolverFirewallConfigOutput) ToResolverFirewallConfigPtrOutputWithContext(ctx context.Context) ResolverFirewallConfigPtrOutput

type ResolverFirewallConfigPtrInput added in v4.9.0 

type ResolverFirewallConfigPtrInput interface {
	pulumi.Input

	ToResolverFirewallConfigPtrOutput() ResolverFirewallConfigPtrOutput
	ToResolverFirewallConfigPtrOutputWithContext(ctx context.Context) ResolverFirewallConfigPtrOutput
}

type ResolverFirewallConfigPtrOutput added in v4.9.0 

type ResolverFirewallConfigPtrOutput struct{ *pulumi.OutputState }

func (ResolverFirewallConfigPtrOutput) Elem added in v4.15.0 

func (o ResolverFirewallConfigPtrOutput) Elem() ResolverFirewallConfigOutput

func (ResolverFirewallConfigPtrOutput) ElementType added in v4.9.0 

func (ResolverFirewallConfigPtrOutput) ElementType() reflect.Type

func (ResolverFirewallConfigPtrOutput) ToResolverFirewallConfigPtrOutput added in v4.9.0 

func (o ResolverFirewallConfigPtrOutput) ToResolverFirewallConfigPtrOutput() ResolverFirewallConfigPtrOutput

func (ResolverFirewallConfigPtrOutput) ToResolverFirewallConfigPtrOutputWithContext added in v4.9.0 

func (o ResolverFirewallConfigPtrOutput) ToResolverFirewallConfigPtrOutputWithContext(ctx context.Context) ResolverFirewallConfigPtrOutput

type ResolverFirewallConfigState added in v4.9.0 

type ResolverFirewallConfigState struct {
	// Determines how Route 53 Resolver handles queries during failures, for example when all traffic that is sent to DNS Firewall fails to receive a reply. By default, fail open is disabled, which means the failure mode is closed. This approach favors security over availability. DNS Firewall blocks queries that it is unable to evaluate properly. If you enable this option, the failure mode is open. This approach favors availability over security. DNS Firewall allows queries to proceed if it is unable to properly evaluate them. Valid values: `ENABLED`, `DISABLED`.
	FirewallFailOpen pulumi.StringPtrInput
	// The AWS account ID of the owner of the VPC that this firewall configuration applies to.
	OwnerId pulumi.StringPtrInput
	// The ID of the VPC that the configuration is for.
	ResourceId pulumi.StringPtrInput
}

func (ResolverFirewallConfigState) ElementType added in v4.9.0 

func (ResolverFirewallConfigState) ElementType() reflect.Type

type ResolverFirewallDomainList 

type ResolverFirewallDomainList struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) of the domain list.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A array of domains for the firewall domain list.
	Domains pulumi.StringArrayOutput `pulumi:"domains"`
	// A name that lets you identify the domain list, to manage and use it.
	Name pulumi.StringOutput `pulumi:"name"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Route 53 Resolver DNS Firewall domain list resource.

## Example Usage

```go package main

import ( 

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

) 

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

```

## Import 

Route 53 Resolver DNS Firewall domain lists can be imported using the Route 53 Resolver DNS Firewall domain list ID, e.g.

```sh 

$ pulumi import aws:route53/resolverFirewallDomainList:ResolverFirewallDomainList example rslvr-fdl-0123456789abcdef

```

func GetResolverFirewallDomainList 

func GetResolverFirewallDomainList(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverFirewallDomainListState, opts ...pulumi.ResourceOption) (*ResolverFirewallDomainList, error)

GetResolverFirewallDomainList gets an existing ResolverFirewallDomainList 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 NewResolverFirewallDomainList 

func NewResolverFirewallDomainList(ctx *pulumi.Context,
	name string, args *ResolverFirewallDomainListArgs, opts ...pulumi.ResourceOption) (*ResolverFirewallDomainList, error)

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

func (*ResolverFirewallDomainList) ElementType 

func (*ResolverFirewallDomainList) ElementType() reflect.Type

func (*ResolverFirewallDomainList) ToResolverFirewallDomainListOutput 

func (i *ResolverFirewallDomainList) ToResolverFirewallDomainListOutput() ResolverFirewallDomainListOutput

func (*ResolverFirewallDomainList) ToResolverFirewallDomainListOutputWithContext 

func (i *ResolverFirewallDomainList) ToResolverFirewallDomainListOutputWithContext(ctx context.Context) ResolverFirewallDomainListOutput

func (*ResolverFirewallDomainList) ToResolverFirewallDomainListPtrOutput 

func (i *ResolverFirewallDomainList) ToResolverFirewallDomainListPtrOutput() ResolverFirewallDomainListPtrOutput

func (*ResolverFirewallDomainList) ToResolverFirewallDomainListPtrOutputWithContext 

func (i *ResolverFirewallDomainList) ToResolverFirewallDomainListPtrOutputWithContext(ctx context.Context) ResolverFirewallDomainListPtrOutput

type ResolverFirewallDomainListArgs 

type ResolverFirewallDomainListArgs struct {
	// A array of domains for the firewall domain list.
	Domains pulumi.StringArrayInput
	// A name that lets you identify the domain list, to manage and use it.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverFirewallDomainList resource.

func (ResolverFirewallDomainListArgs) ElementType 

func (ResolverFirewallDomainListArgs) ElementType() reflect.Type

type ResolverFirewallDomainListArray 

type ResolverFirewallDomainListArray []ResolverFirewallDomainListInput

func (ResolverFirewallDomainListArray) ElementType 

func (ResolverFirewallDomainListArray) ElementType() reflect.Type

func (ResolverFirewallDomainListArray) ToResolverFirewallDomainListArrayOutput 

func (i ResolverFirewallDomainListArray) ToResolverFirewallDomainListArrayOutput() ResolverFirewallDomainListArrayOutput

func (ResolverFirewallDomainListArray) ToResolverFirewallDomainListArrayOutputWithContext 

func (i ResolverFirewallDomainListArray) ToResolverFirewallDomainListArrayOutputWithContext(ctx context.Context) ResolverFirewallDomainListArrayOutput

type ResolverFirewallDomainListArrayInput 

type ResolverFirewallDomainListArrayInput interface {
	pulumi.Input

	ToResolverFirewallDomainListArrayOutput() ResolverFirewallDomainListArrayOutput
	ToResolverFirewallDomainListArrayOutputWithContext(context.Context) ResolverFirewallDomainListArrayOutput
}

ResolverFirewallDomainListArrayInput is an input type that accepts ResolverFirewallDomainListArray and ResolverFirewallDomainListArrayOutput values. You can construct a concrete instance of `ResolverFirewallDomainListArrayInput` via: 

ResolverFirewallDomainListArray{ ResolverFirewallDomainListArgs{...} }

type ResolverFirewallDomainListArrayOutput 

type ResolverFirewallDomainListArrayOutput struct{ *pulumi.OutputState }

func (ResolverFirewallDomainListArrayOutput) ElementType 

func (ResolverFirewallDomainListArrayOutput) ElementType() reflect.Type

func (ResolverFirewallDomainListArrayOutput) Index 

func (o ResolverFirewallDomainListArrayOutput) Index(i pulumi.IntInput) ResolverFirewallDomainListOutput

func (ResolverFirewallDomainListArrayOutput) ToResolverFirewallDomainListArrayOutput 

func (o ResolverFirewallDomainListArrayOutput) ToResolverFirewallDomainListArrayOutput() ResolverFirewallDomainListArrayOutput

func (ResolverFirewallDomainListArrayOutput) ToResolverFirewallDomainListArrayOutputWithContext 

func (o ResolverFirewallDomainListArrayOutput) ToResolverFirewallDomainListArrayOutputWithContext(ctx context.Context) ResolverFirewallDomainListArrayOutput

type ResolverFirewallDomainListInput 

type ResolverFirewallDomainListInput interface {
	pulumi.Input

	ToResolverFirewallDomainListOutput() ResolverFirewallDomainListOutput
	ToResolverFirewallDomainListOutputWithContext(ctx context.Context) ResolverFirewallDomainListOutput
}

type ResolverFirewallDomainListMap 

type ResolverFirewallDomainListMap map[string]ResolverFirewallDomainListInput

func (ResolverFirewallDomainListMap) ElementType 

func (ResolverFirewallDomainListMap) ElementType() reflect.Type

func (ResolverFirewallDomainListMap) ToResolverFirewallDomainListMapOutput 

func (i ResolverFirewallDomainListMap) ToResolverFirewallDomainListMapOutput() ResolverFirewallDomainListMapOutput

func (ResolverFirewallDomainListMap) ToResolverFirewallDomainListMapOutputWithContext 

func (i ResolverFirewallDomainListMap) ToResolverFirewallDomainListMapOutputWithContext(ctx context.Context) ResolverFirewallDomainListMapOutput

type ResolverFirewallDomainListMapInput 

type ResolverFirewallDomainListMapInput interface {
	pulumi.Input

	ToResolverFirewallDomainListMapOutput() ResolverFirewallDomainListMapOutput
	ToResolverFirewallDomainListMapOutputWithContext(context.Context) ResolverFirewallDomainListMapOutput
}

ResolverFirewallDomainListMapInput is an input type that accepts ResolverFirewallDomainListMap and ResolverFirewallDomainListMapOutput values. You can construct a concrete instance of `ResolverFirewallDomainListMapInput` via: 

ResolverFirewallDomainListMap{ "key": ResolverFirewallDomainListArgs{...} }

type ResolverFirewallDomainListMapOutput 

type ResolverFirewallDomainListMapOutput struct{ *pulumi.OutputState }

func (ResolverFirewallDomainListMapOutput) ElementType 

func (ResolverFirewallDomainListMapOutput) ElementType() reflect.Type

func (ResolverFirewallDomainListMapOutput) MapIndex 

func (o ResolverFirewallDomainListMapOutput) MapIndex(k pulumi.StringInput) ResolverFirewallDomainListOutput

func (ResolverFirewallDomainListMapOutput) ToResolverFirewallDomainListMapOutput 

func (o ResolverFirewallDomainListMapOutput) ToResolverFirewallDomainListMapOutput() ResolverFirewallDomainListMapOutput

func (ResolverFirewallDomainListMapOutput) ToResolverFirewallDomainListMapOutputWithContext 

func (o ResolverFirewallDomainListMapOutput) ToResolverFirewallDomainListMapOutputWithContext(ctx context.Context) ResolverFirewallDomainListMapOutput

type ResolverFirewallDomainListOutput 

type ResolverFirewallDomainListOutput struct{ *pulumi.OutputState }

func (ResolverFirewallDomainListOutput) ElementType 

func (ResolverFirewallDomainListOutput) ElementType() reflect.Type

func (ResolverFirewallDomainListOutput) ToResolverFirewallDomainListOutput 

func (o ResolverFirewallDomainListOutput) ToResolverFirewallDomainListOutput() ResolverFirewallDomainListOutput

func (ResolverFirewallDomainListOutput) ToResolverFirewallDomainListOutputWithContext 

func (o ResolverFirewallDomainListOutput) ToResolverFirewallDomainListOutputWithContext(ctx context.Context) ResolverFirewallDomainListOutput

func (ResolverFirewallDomainListOutput) ToResolverFirewallDomainListPtrOutput 

func (o ResolverFirewallDomainListOutput) ToResolverFirewallDomainListPtrOutput() ResolverFirewallDomainListPtrOutput

func (ResolverFirewallDomainListOutput) ToResolverFirewallDomainListPtrOutputWithContext 

func (o ResolverFirewallDomainListOutput) ToResolverFirewallDomainListPtrOutputWithContext(ctx context.Context) ResolverFirewallDomainListPtrOutput

type ResolverFirewallDomainListPtrInput 

type ResolverFirewallDomainListPtrInput interface {
	pulumi.Input

	ToResolverFirewallDomainListPtrOutput() ResolverFirewallDomainListPtrOutput
	ToResolverFirewallDomainListPtrOutputWithContext(ctx context.Context) ResolverFirewallDomainListPtrOutput
}

type ResolverFirewallDomainListPtrOutput 

type ResolverFirewallDomainListPtrOutput struct{ *pulumi.OutputState }

func (ResolverFirewallDomainListPtrOutput) Elem added in v4.15.0 

func (o ResolverFirewallDomainListPtrOutput) Elem() ResolverFirewallDomainListOutput

func (ResolverFirewallDomainListPtrOutput) ElementType 

func (ResolverFirewallDomainListPtrOutput) ElementType() reflect.Type

func (ResolverFirewallDomainListPtrOutput) ToResolverFirewallDomainListPtrOutput 

func (o ResolverFirewallDomainListPtrOutput) ToResolverFirewallDomainListPtrOutput() ResolverFirewallDomainListPtrOutput

func (ResolverFirewallDomainListPtrOutput) ToResolverFirewallDomainListPtrOutputWithContext 

func (o ResolverFirewallDomainListPtrOutput) ToResolverFirewallDomainListPtrOutputWithContext(ctx context.Context) ResolverFirewallDomainListPtrOutput

type ResolverFirewallDomainListState 

type ResolverFirewallDomainListState struct {
	// The ARN (Amazon Resource Name) of the domain list.
	Arn pulumi.StringPtrInput
	// A array of domains for the firewall domain list.
	Domains pulumi.StringArrayInput
	// A name that lets you identify the domain list, to manage and use it.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (ResolverFirewallDomainListState) ElementType 

func (ResolverFirewallDomainListState) ElementType() reflect.Type

type ResolverFirewallRule added in v4.2.0 

type ResolverFirewallRule struct {
	pulumi.CustomResourceState

	// The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list. Valid values: `ALLOW`, `BLOCK`, `ALERT`.
	Action pulumi.StringOutput `pulumi:"action"`
	// The DNS record's type. This determines the format of the record value that you provided in BlockOverrideDomain. Value values: `CNAME`.
	BlockOverrideDnsType pulumi.StringPtrOutput `pulumi:"blockOverrideDnsType"`
	// The custom DNS record to send back in response to the query.
	BlockOverrideDomain pulumi.StringPtrOutput `pulumi:"blockOverrideDomain"`
	// The recommended amount of time, in seconds, for the DNS resolver or web browser to cache the provided override record. Minimum value of 0. Maximum value of 604800.
	BlockOverrideTtl pulumi.IntPtrOutput `pulumi:"blockOverrideTtl"`
	// The way that you want DNS Firewall to block the request. Valid values: `NODATA`, `NXDOMAIN`, `OVERRIDE`.
	BlockResponse pulumi.StringPtrOutput `pulumi:"blockResponse"`
	// The ID of the domain list that you want to use in the rule.
	FirewallDomainListId pulumi.StringOutput `pulumi:"firewallDomainListId"`
	// The unique identifier of the firewall rule group where you want to create the rule.
	FirewallRuleGroupId pulumi.StringOutput `pulumi:"firewallRuleGroupId"`
	// A name that lets you identify the rule, to manage and use it.
	Name pulumi.StringOutput `pulumi:"name"`
	// The setting that determines the processing order of the rule in the rule group. DNS Firewall processes the rules in a rule group by order of priority, starting from the lowest setting.
	Priority pulumi.IntOutput `pulumi:"priority"`
}

Provides a Route 53 Resolver DNS Firewall rule resource.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResolverFirewallDomainList, err := route53.NewResolverFirewallDomainList(ctx, "exampleResolverFirewallDomainList", &route53.ResolverFirewallDomainListArgs{
			Domains: pulumi.StringArray{
				pulumi.String("example.com"),
			},
			Tags: nil,
		})
		if err != nil {
			return err
		}
		exampleResolverFirewallRuleGroup, err := route53.NewResolverFirewallRuleGroup(ctx, "exampleResolverFirewallRuleGroup", &route53.ResolverFirewallRuleGroupArgs{
			Tags: nil,
		})
		if err != nil {
			return err
		}
		_, err = route53.NewResolverFirewallRule(ctx, "exampleResolverFirewallRule", &route53.ResolverFirewallRuleArgs{
			Action:               pulumi.String("BLOCK"),
			BlockOverrideDnsType: pulumi.String("CNAME"),
			BlockOverrideDomain:  pulumi.String("example.com"),
			BlockOverrideTtl:     pulumi.Int(1),
			BlockResponse:        pulumi.String("OVERRIDE"),
			FirewallDomainListId: exampleResolverFirewallDomainList.ID(),
			FirewallRuleGroupId:  exampleResolverFirewallRuleGroup.ID(),
			Priority:             pulumi.Int(100),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import 

Route 53 Resolver DNS Firewall rules can be imported using the Route 53 Resolver DNS Firewall rule group ID and domain list ID separated by ':', e.g.

```sh 

$ pulumi import aws:route53/resolverFirewallRule:ResolverFirewallRule example rslvr-frg-0123456789abcdef:rslvr-fdl-0123456789abcdef

```

func GetResolverFirewallRule added in v4.2.0 

func GetResolverFirewallRule(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverFirewallRuleState, opts ...pulumi.ResourceOption) (*ResolverFirewallRule, error)

GetResolverFirewallRule gets an existing ResolverFirewallRule 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 NewResolverFirewallRule added in v4.2.0 

func NewResolverFirewallRule(ctx *pulumi.Context,
	name string, args *ResolverFirewallRuleArgs, opts ...pulumi.ResourceOption) (*ResolverFirewallRule, error)

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

func (*ResolverFirewallRule) ElementType added in v4.2.0 

func (*ResolverFirewallRule) ElementType() reflect.Type

func (*ResolverFirewallRule) ToResolverFirewallRuleOutput added in v4.2.0 

func (i *ResolverFirewallRule) ToResolverFirewallRuleOutput() ResolverFirewallRuleOutput

func (*ResolverFirewallRule) ToResolverFirewallRuleOutputWithContext added in v4.2.0 

func (i *ResolverFirewallRule) ToResolverFirewallRuleOutputWithContext(ctx context.Context) ResolverFirewallRuleOutput

func (*ResolverFirewallRule) ToResolverFirewallRulePtrOutput added in v4.2.0 

func (i *ResolverFirewallRule) ToResolverFirewallRulePtrOutput() ResolverFirewallRulePtrOutput

func (*ResolverFirewallRule) ToResolverFirewallRulePtrOutputWithContext added in v4.2.0 

func (i *ResolverFirewallRule) ToResolverFirewallRulePtrOutputWithContext(ctx context.Context) ResolverFirewallRulePtrOutput

type ResolverFirewallRuleArgs added in v4.2.0 

type ResolverFirewallRuleArgs struct {
	// The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list. Valid values: `ALLOW`, `BLOCK`, `ALERT`.
	Action pulumi.StringInput
	// The DNS record's type. This determines the format of the record value that you provided in BlockOverrideDomain. Value values: `CNAME`.
	BlockOverrideDnsType pulumi.StringPtrInput
	// The custom DNS record to send back in response to the query.
	BlockOverrideDomain pulumi.StringPtrInput
	// The recommended amount of time, in seconds, for the DNS resolver or web browser to cache the provided override record. Minimum value of 0. Maximum value of 604800.
	BlockOverrideTtl pulumi.IntPtrInput
	// The way that you want DNS Firewall to block the request. Valid values: `NODATA`, `NXDOMAIN`, `OVERRIDE`.
	BlockResponse pulumi.StringPtrInput
	// The ID of the domain list that you want to use in the rule.
	FirewallDomainListId pulumi.StringInput
	// The unique identifier of the firewall rule group where you want to create the rule.
	FirewallRuleGroupId pulumi.StringInput
	// A name that lets you identify the rule, to manage and use it.
	Name pulumi.StringPtrInput
	// The setting that determines the processing order of the rule in the rule group. DNS Firewall processes the rules in a rule group by order of priority, starting from the lowest setting.
	Priority pulumi.IntInput
}

The set of arguments for constructing a ResolverFirewallRule resource.

func (ResolverFirewallRuleArgs) ElementType added in v4.2.0 

func (ResolverFirewallRuleArgs) ElementType() reflect.Type

type ResolverFirewallRuleArray added in v4.2.0 

type ResolverFirewallRuleArray []ResolverFirewallRuleInput

func (ResolverFirewallRuleArray) ElementType added in v4.2.0 

func (ResolverFirewallRuleArray) ElementType() reflect.Type

func (ResolverFirewallRuleArray) ToResolverFirewallRuleArrayOutput added in v4.2.0 

func (i ResolverFirewallRuleArray) ToResolverFirewallRuleArrayOutput() ResolverFirewallRuleArrayOutput

func (ResolverFirewallRuleArray) ToResolverFirewallRuleArrayOutputWithContext added in v4.2.0 

func (i ResolverFirewallRuleArray) ToResolverFirewallRuleArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleArrayOutput

type ResolverFirewallRuleArrayInput added in v4.2.0 

type ResolverFirewallRuleArrayInput interface {
	pulumi.Input

	ToResolverFirewallRuleArrayOutput() ResolverFirewallRuleArrayOutput
	ToResolverFirewallRuleArrayOutputWithContext(context.Context) ResolverFirewallRuleArrayOutput
}

ResolverFirewallRuleArrayInput is an input type that accepts ResolverFirewallRuleArray and ResolverFirewallRuleArrayOutput values. You can construct a concrete instance of `ResolverFirewallRuleArrayInput` via: 

ResolverFirewallRuleArray{ ResolverFirewallRuleArgs{...} }

type ResolverFirewallRuleArrayOutput added in v4.2.0 

type ResolverFirewallRuleArrayOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleArrayOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleArrayOutput) ElementType() reflect.Type

func (ResolverFirewallRuleArrayOutput) Index added in v4.2.0 

func (o ResolverFirewallRuleArrayOutput) Index(i pulumi.IntInput) ResolverFirewallRuleOutput

func (ResolverFirewallRuleArrayOutput) ToResolverFirewallRuleArrayOutput added in v4.2.0 

func (o ResolverFirewallRuleArrayOutput) ToResolverFirewallRuleArrayOutput() ResolverFirewallRuleArrayOutput

func (ResolverFirewallRuleArrayOutput) ToResolverFirewallRuleArrayOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleArrayOutput) ToResolverFirewallRuleArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleArrayOutput

type ResolverFirewallRuleGroup 

type ResolverFirewallRuleGroup struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) of the rule group.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A name that lets you identify the rule group, to manage and use it.
	Name pulumi.StringOutput `pulumi:"name"`
	// The AWS account ID for the account that created the rule group. When a rule group is shared with your account, this is the account that has shared the rule group with you.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// Whether the rule group 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). Valid values: `NOT_SHARED`, `SHARED_BY_ME`, `SHARED_WITH_ME`
	ShareStatus pulumi.StringOutput `pulumi:"shareStatus"`
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Route 53 Resolver DNS Firewall rule group resource.

## Example Usage

```go package main

import ( 

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

) 

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

```

## Import 

Route 53 Resolver DNS Firewall rule groups can be imported using the Route 53 Resolver DNS Firewall rule group ID, e.g.

```sh 

$ pulumi import aws:route53/resolverFirewallRuleGroup:ResolverFirewallRuleGroup example rslvr-frg-0123456789abcdef

```

func GetResolverFirewallRuleGroup 

func GetResolverFirewallRuleGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverFirewallRuleGroupState, opts ...pulumi.ResourceOption) (*ResolverFirewallRuleGroup, error)

GetResolverFirewallRuleGroup gets an existing ResolverFirewallRuleGroup 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 NewResolverFirewallRuleGroup 

func NewResolverFirewallRuleGroup(ctx *pulumi.Context,
	name string, args *ResolverFirewallRuleGroupArgs, opts ...pulumi.ResourceOption) (*ResolverFirewallRuleGroup, error)

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

func (*ResolverFirewallRuleGroup) ElementType 

func (*ResolverFirewallRuleGroup) ElementType() reflect.Type

func (*ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupOutput 

func (i *ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupOutput() ResolverFirewallRuleGroupOutput

func (*ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupOutputWithContext 

func (i *ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupOutput

func (*ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupPtrOutput 

func (i *ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupPtrOutput() ResolverFirewallRuleGroupPtrOutput

func (*ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupPtrOutputWithContext 

func (i *ResolverFirewallRuleGroup) ToResolverFirewallRuleGroupPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupPtrOutput

type ResolverFirewallRuleGroupArgs 

type ResolverFirewallRuleGroupArgs struct {
	// A name that lets you identify the rule group, to manage and use it.
	Name pulumi.StringPtrInput
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverFirewallRuleGroup resource.

func (ResolverFirewallRuleGroupArgs) ElementType 

func (ResolverFirewallRuleGroupArgs) ElementType() reflect.Type

type ResolverFirewallRuleGroupArray 

type ResolverFirewallRuleGroupArray []ResolverFirewallRuleGroupInput

func (ResolverFirewallRuleGroupArray) ElementType 

func (ResolverFirewallRuleGroupArray) ElementType() reflect.Type

func (ResolverFirewallRuleGroupArray) ToResolverFirewallRuleGroupArrayOutput 

func (i ResolverFirewallRuleGroupArray) ToResolverFirewallRuleGroupArrayOutput() ResolverFirewallRuleGroupArrayOutput

func (ResolverFirewallRuleGroupArray) ToResolverFirewallRuleGroupArrayOutputWithContext 

func (i ResolverFirewallRuleGroupArray) ToResolverFirewallRuleGroupArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupArrayOutput

type ResolverFirewallRuleGroupArrayInput 

type ResolverFirewallRuleGroupArrayInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupArrayOutput() ResolverFirewallRuleGroupArrayOutput
	ToResolverFirewallRuleGroupArrayOutputWithContext(context.Context) ResolverFirewallRuleGroupArrayOutput
}

ResolverFirewallRuleGroupArrayInput is an input type that accepts ResolverFirewallRuleGroupArray and ResolverFirewallRuleGroupArrayOutput values. You can construct a concrete instance of `ResolverFirewallRuleGroupArrayInput` via: 

ResolverFirewallRuleGroupArray{ ResolverFirewallRuleGroupArgs{...} }

type ResolverFirewallRuleGroupArrayOutput 

type ResolverFirewallRuleGroupArrayOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupArrayOutput) ElementType 

func (ResolverFirewallRuleGroupArrayOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupArrayOutput) Index 

func (o ResolverFirewallRuleGroupArrayOutput) Index(i pulumi.IntInput) ResolverFirewallRuleGroupOutput

func (ResolverFirewallRuleGroupArrayOutput) ToResolverFirewallRuleGroupArrayOutput 

func (o ResolverFirewallRuleGroupArrayOutput) ToResolverFirewallRuleGroupArrayOutput() ResolverFirewallRuleGroupArrayOutput

func (ResolverFirewallRuleGroupArrayOutput) ToResolverFirewallRuleGroupArrayOutputWithContext 

func (o ResolverFirewallRuleGroupArrayOutput) ToResolverFirewallRuleGroupArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupArrayOutput

type ResolverFirewallRuleGroupAssociation added in v4.2.0 

type ResolverFirewallRuleGroupAssociation struct {
	pulumi.CustomResourceState

	// The ARN (Amazon Resource Name) of the firewall rule group association.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The unique identifier of the firewall rule group.
	FirewallRuleGroupId pulumi.StringOutput `pulumi:"firewallRuleGroupId"`
	// If enabled, this setting disallows modification or removal of the association, to help prevent against accidentally altering DNS firewall protections. Valid values: `ENABLED`, `DISABLED`.
	MutationProtection pulumi.StringOutput `pulumi:"mutationProtection"`
	// A name that lets you identify the rule group association, to manage and use it.
	Name pulumi.StringOutput `pulumi:"name"`
	// The setting that determines the processing order of the rule group among the rule groups that you associate with the specified VPC. DNS Firewall filters VPC traffic starting from the rule group with the lowest numeric priority setting.
	Priority pulumi.IntOutput `pulumi:"priority"`
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The unique identifier of the VPC that you want to associate with the rule group.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
}

Provides a Route 53 Resolver DNS Firewall rule group association resource.

## Example Usage

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResolverFirewallRuleGroup, err := route53.NewResolverFirewallRuleGroup(ctx, "exampleResolverFirewallRuleGroup", nil)
		if err != nil {
			return err
		}
		_, err = route53.NewResolverFirewallRuleGroupAssociation(ctx, "exampleResolverFirewallRuleGroupAssociation", &route53.ResolverFirewallRuleGroupAssociationArgs{
			FirewallRuleGroupId: exampleResolverFirewallRuleGroup.ID(),
			Priority:            pulumi.Int(100),
			VpcId:               pulumi.Any(aws_vpc.Example.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Route 53 Resolver DNS Firewall rule group associations can be imported using the Route 53 Resolver DNS Firewall rule group association ID, e.g.

```sh 

$ pulumi import aws:route53/resolverFirewallRuleGroupAssociation:ResolverFirewallRuleGroupAssociation example rslvr-frgassoc-0123456789abcdef

```

func GetResolverFirewallRuleGroupAssociation added in v4.2.0 

func GetResolverFirewallRuleGroupAssociation(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResolverFirewallRuleGroupAssociationState, opts ...pulumi.ResourceOption) (*ResolverFirewallRuleGroupAssociation, error)

GetResolverFirewallRuleGroupAssociation gets an existing ResolverFirewallRuleGroupAssociation 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 NewResolverFirewallRuleGroupAssociation added in v4.2.0 

func NewResolverFirewallRuleGroupAssociation(ctx *pulumi.Context,
	name string, args *ResolverFirewallRuleGroupAssociationArgs, opts ...pulumi.ResourceOption) (*ResolverFirewallRuleGroupAssociation, error)

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

func (*ResolverFirewallRuleGroupAssociation) ElementType added in v4.2.0 

func (*ResolverFirewallRuleGroupAssociation) ElementType() reflect.Type

func (*ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationOutput added in v4.2.0 

func (i *ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationOutput() ResolverFirewallRuleGroupAssociationOutput

func (*ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationOutputWithContext added in v4.2.0 

func (i *ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationOutput

func (*ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationPtrOutput added in v4.2.0 

func (i *ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationPtrOutput() ResolverFirewallRuleGroupAssociationPtrOutput

func (*ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext added in v4.2.0 

func (i *ResolverFirewallRuleGroupAssociation) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationPtrOutput

type ResolverFirewallRuleGroupAssociationArgs added in v4.2.0 

type ResolverFirewallRuleGroupAssociationArgs struct {
	// The unique identifier of the firewall rule group.
	FirewallRuleGroupId pulumi.StringInput
	// If enabled, this setting disallows modification or removal of the association, to help prevent against accidentally altering DNS firewall protections. Valid values: `ENABLED`, `DISABLED`.
	MutationProtection pulumi.StringPtrInput
	// A name that lets you identify the rule group association, to manage and use it.
	Name pulumi.StringPtrInput
	// The setting that determines the processing order of the rule group among the rule groups that you associate with the specified VPC. DNS Firewall filters VPC traffic starting from the rule group with the lowest numeric priority setting.
	Priority pulumi.IntInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// The unique identifier of the VPC that you want to associate with the rule group.
	VpcId pulumi.StringInput
}

The set of arguments for constructing a ResolverFirewallRuleGroupAssociation resource.

func (ResolverFirewallRuleGroupAssociationArgs) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationArgs) ElementType() reflect.Type

type ResolverFirewallRuleGroupAssociationArray added in v4.2.0 

type ResolverFirewallRuleGroupAssociationArray []ResolverFirewallRuleGroupAssociationInput

func (ResolverFirewallRuleGroupAssociationArray) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationArray) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationArray) ToResolverFirewallRuleGroupAssociationArrayOutput added in v4.2.0 

func (i ResolverFirewallRuleGroupAssociationArray) ToResolverFirewallRuleGroupAssociationArrayOutput() ResolverFirewallRuleGroupAssociationArrayOutput

func (ResolverFirewallRuleGroupAssociationArray) ToResolverFirewallRuleGroupAssociationArrayOutputWithContext added in v4.2.0 

func (i ResolverFirewallRuleGroupAssociationArray) ToResolverFirewallRuleGroupAssociationArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationArrayOutput

type ResolverFirewallRuleGroupAssociationArrayInput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationArrayInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupAssociationArrayOutput() ResolverFirewallRuleGroupAssociationArrayOutput
	ToResolverFirewallRuleGroupAssociationArrayOutputWithContext(context.Context) ResolverFirewallRuleGroupAssociationArrayOutput
}

ResolverFirewallRuleGroupAssociationArrayInput is an input type that accepts ResolverFirewallRuleGroupAssociationArray and ResolverFirewallRuleGroupAssociationArrayOutput values. You can construct a concrete instance of `ResolverFirewallRuleGroupAssociationArrayInput` via: 

ResolverFirewallRuleGroupAssociationArray{ ResolverFirewallRuleGroupAssociationArgs{...} }

type ResolverFirewallRuleGroupAssociationArrayOutput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationArrayOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupAssociationArrayOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationArrayOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationArrayOutput) Index added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationArrayOutput) Index(i pulumi.IntInput) ResolverFirewallRuleGroupAssociationOutput

func (ResolverFirewallRuleGroupAssociationArrayOutput) ToResolverFirewallRuleGroupAssociationArrayOutput added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationArrayOutput) ToResolverFirewallRuleGroupAssociationArrayOutput() ResolverFirewallRuleGroupAssociationArrayOutput

func (ResolverFirewallRuleGroupAssociationArrayOutput) ToResolverFirewallRuleGroupAssociationArrayOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationArrayOutput) ToResolverFirewallRuleGroupAssociationArrayOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationArrayOutput

type ResolverFirewallRuleGroupAssociationInput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupAssociationOutput() ResolverFirewallRuleGroupAssociationOutput
	ToResolverFirewallRuleGroupAssociationOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationOutput
}

type ResolverFirewallRuleGroupAssociationMap added in v4.2.0 

type ResolverFirewallRuleGroupAssociationMap map[string]ResolverFirewallRuleGroupAssociationInput

func (ResolverFirewallRuleGroupAssociationMap) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationMap) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationMap) ToResolverFirewallRuleGroupAssociationMapOutput added in v4.2.0 

func (i ResolverFirewallRuleGroupAssociationMap) ToResolverFirewallRuleGroupAssociationMapOutput() ResolverFirewallRuleGroupAssociationMapOutput

func (ResolverFirewallRuleGroupAssociationMap) ToResolverFirewallRuleGroupAssociationMapOutputWithContext added in v4.2.0 

func (i ResolverFirewallRuleGroupAssociationMap) ToResolverFirewallRuleGroupAssociationMapOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationMapOutput

type ResolverFirewallRuleGroupAssociationMapInput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationMapInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupAssociationMapOutput() ResolverFirewallRuleGroupAssociationMapOutput
	ToResolverFirewallRuleGroupAssociationMapOutputWithContext(context.Context) ResolverFirewallRuleGroupAssociationMapOutput
}

ResolverFirewallRuleGroupAssociationMapInput is an input type that accepts ResolverFirewallRuleGroupAssociationMap and ResolverFirewallRuleGroupAssociationMapOutput values. You can construct a concrete instance of `ResolverFirewallRuleGroupAssociationMapInput` via: 

ResolverFirewallRuleGroupAssociationMap{ "key": ResolverFirewallRuleGroupAssociationArgs{...} }

type ResolverFirewallRuleGroupAssociationMapOutput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationMapOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupAssociationMapOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationMapOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationMapOutput) MapIndex added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationMapOutput) MapIndex(k pulumi.StringInput) ResolverFirewallRuleGroupAssociationOutput

func (ResolverFirewallRuleGroupAssociationMapOutput) ToResolverFirewallRuleGroupAssociationMapOutput added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationMapOutput) ToResolverFirewallRuleGroupAssociationMapOutput() ResolverFirewallRuleGroupAssociationMapOutput

func (ResolverFirewallRuleGroupAssociationMapOutput) ToResolverFirewallRuleGroupAssociationMapOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationMapOutput) ToResolverFirewallRuleGroupAssociationMapOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationMapOutput

type ResolverFirewallRuleGroupAssociationOutput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupAssociationOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationOutput added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationOutput() ResolverFirewallRuleGroupAssociationOutput

func (ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationOutput

func (ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationPtrOutput added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationPtrOutput() ResolverFirewallRuleGroupAssociationPtrOutput

func (ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationOutput) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationPtrOutput

type ResolverFirewallRuleGroupAssociationPtrInput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationPtrInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupAssociationPtrOutput() ResolverFirewallRuleGroupAssociationPtrOutput
	ToResolverFirewallRuleGroupAssociationPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationPtrOutput
}

type ResolverFirewallRuleGroupAssociationPtrOutput added in v4.2.0 

type ResolverFirewallRuleGroupAssociationPtrOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupAssociationPtrOutput) Elem added in v4.15.0 

func (o ResolverFirewallRuleGroupAssociationPtrOutput) Elem() ResolverFirewallRuleGroupAssociationOutput

func (ResolverFirewallRuleGroupAssociationPtrOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationPtrOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupAssociationPtrOutput) ToResolverFirewallRuleGroupAssociationPtrOutput added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationPtrOutput) ToResolverFirewallRuleGroupAssociationPtrOutput() ResolverFirewallRuleGroupAssociationPtrOutput

func (ResolverFirewallRuleGroupAssociationPtrOutput) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleGroupAssociationPtrOutput) ToResolverFirewallRuleGroupAssociationPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupAssociationPtrOutput

type ResolverFirewallRuleGroupAssociationState added in v4.2.0 

type ResolverFirewallRuleGroupAssociationState struct {
	// The ARN (Amazon Resource Name) of the firewall rule group association.
	Arn pulumi.StringPtrInput
	// The unique identifier of the firewall rule group.
	FirewallRuleGroupId pulumi.StringPtrInput
	// If enabled, this setting disallows modification or removal of the association, to help prevent against accidentally altering DNS firewall protections. Valid values: `ENABLED`, `DISABLED`.
	MutationProtection pulumi.StringPtrInput
	// A name that lets you identify the rule group association, to manage and use it.
	Name pulumi.StringPtrInput
	// The setting that determines the processing order of the rule group among the rule groups that you associate with the specified VPC. DNS Firewall filters VPC traffic starting from the rule group with the lowest numeric priority setting.
	Priority pulumi.IntPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
	// The unique identifier of the VPC that you want to associate with the rule group.
	VpcId pulumi.StringPtrInput
}

func (ResolverFirewallRuleGroupAssociationState) ElementType added in v4.2.0 

func (ResolverFirewallRuleGroupAssociationState) ElementType() reflect.Type

type ResolverFirewallRuleGroupInput 

type ResolverFirewallRuleGroupInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupOutput() ResolverFirewallRuleGroupOutput
	ToResolverFirewallRuleGroupOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupOutput
}

type ResolverFirewallRuleGroupMap 

type ResolverFirewallRuleGroupMap map[string]ResolverFirewallRuleGroupInput

func (ResolverFirewallRuleGroupMap) ElementType 

func (ResolverFirewallRuleGroupMap) ElementType() reflect.Type

func (ResolverFirewallRuleGroupMap) ToResolverFirewallRuleGroupMapOutput 

func (i ResolverFirewallRuleGroupMap) ToResolverFirewallRuleGroupMapOutput() ResolverFirewallRuleGroupMapOutput

func (ResolverFirewallRuleGroupMap) ToResolverFirewallRuleGroupMapOutputWithContext 

func (i ResolverFirewallRuleGroupMap) ToResolverFirewallRuleGroupMapOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupMapOutput

type ResolverFirewallRuleGroupMapInput 

type ResolverFirewallRuleGroupMapInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupMapOutput() ResolverFirewallRuleGroupMapOutput
	ToResolverFirewallRuleGroupMapOutputWithContext(context.Context) ResolverFirewallRuleGroupMapOutput
}

ResolverFirewallRuleGroupMapInput is an input type that accepts ResolverFirewallRuleGroupMap and ResolverFirewallRuleGroupMapOutput values. You can construct a concrete instance of `ResolverFirewallRuleGroupMapInput` via: 

ResolverFirewallRuleGroupMap{ "key": ResolverFirewallRuleGroupArgs{...} }

type ResolverFirewallRuleGroupMapOutput 

type ResolverFirewallRuleGroupMapOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupMapOutput) ElementType 

func (ResolverFirewallRuleGroupMapOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupMapOutput) MapIndex 

func (o ResolverFirewallRuleGroupMapOutput) MapIndex(k pulumi.StringInput) ResolverFirewallRuleGroupOutput

func (ResolverFirewallRuleGroupMapOutput) ToResolverFirewallRuleGroupMapOutput 

func (o ResolverFirewallRuleGroupMapOutput) ToResolverFirewallRuleGroupMapOutput() ResolverFirewallRuleGroupMapOutput

func (ResolverFirewallRuleGroupMapOutput) ToResolverFirewallRuleGroupMapOutputWithContext 

func (o ResolverFirewallRuleGroupMapOutput) ToResolverFirewallRuleGroupMapOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupMapOutput

type ResolverFirewallRuleGroupOutput 

type ResolverFirewallRuleGroupOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupOutput) ElementType 

func (ResolverFirewallRuleGroupOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupOutput 

func (o ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupOutput() ResolverFirewallRuleGroupOutput

func (ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupOutputWithContext 

func (o ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupOutput

func (ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupPtrOutput 

func (o ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupPtrOutput() ResolverFirewallRuleGroupPtrOutput

func (ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupPtrOutputWithContext 

func (o ResolverFirewallRuleGroupOutput) ToResolverFirewallRuleGroupPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupPtrOutput

type ResolverFirewallRuleGroupPtrInput 

type ResolverFirewallRuleGroupPtrInput interface {
	pulumi.Input

	ToResolverFirewallRuleGroupPtrOutput() ResolverFirewallRuleGroupPtrOutput
	ToResolverFirewallRuleGroupPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupPtrOutput
}

type ResolverFirewallRuleGroupPtrOutput 

type ResolverFirewallRuleGroupPtrOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleGroupPtrOutput) Elem added in v4.15.0 

func (o ResolverFirewallRuleGroupPtrOutput) Elem() ResolverFirewallRuleGroupOutput

func (ResolverFirewallRuleGroupPtrOutput) ElementType 

func (ResolverFirewallRuleGroupPtrOutput) ElementType() reflect.Type

func (ResolverFirewallRuleGroupPtrOutput) ToResolverFirewallRuleGroupPtrOutput 

func (o ResolverFirewallRuleGroupPtrOutput) ToResolverFirewallRuleGroupPtrOutput() ResolverFirewallRuleGroupPtrOutput

func (ResolverFirewallRuleGroupPtrOutput) ToResolverFirewallRuleGroupPtrOutputWithContext 

func (o ResolverFirewallRuleGroupPtrOutput) ToResolverFirewallRuleGroupPtrOutputWithContext(ctx context.Context) ResolverFirewallRuleGroupPtrOutput

type ResolverFirewallRuleGroupState 

type ResolverFirewallRuleGroupState struct {
	// The ARN (Amazon Resource Name) of the rule group.
	Arn pulumi.StringPtrInput
	// A name that lets you identify the rule group, to manage and use it.
	Name pulumi.StringPtrInput
	// The AWS account ID for the account that created the rule group. When a rule group is shared with your account, this is the account that has shared the rule group with you.
	OwnerId pulumi.StringPtrInput
	// Whether the rule group 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). Valid values: `NOT_SHARED`, `SHARED_BY_ME`, `SHARED_WITH_ME`
	ShareStatus pulumi.StringPtrInput
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (ResolverFirewallRuleGroupState) ElementType 

func (ResolverFirewallRuleGroupState) ElementType() reflect.Type

type ResolverFirewallRuleInput added in v4.2.0 

type ResolverFirewallRuleInput interface {
	pulumi.Input

	ToResolverFirewallRuleOutput() ResolverFirewallRuleOutput
	ToResolverFirewallRuleOutputWithContext(ctx context.Context) ResolverFirewallRuleOutput
}

type ResolverFirewallRuleMap added in v4.2.0 

type ResolverFirewallRuleMap map[string]ResolverFirewallRuleInput

func (ResolverFirewallRuleMap) ElementType added in v4.2.0 

func (ResolverFirewallRuleMap) ElementType() reflect.Type

func (ResolverFirewallRuleMap) ToResolverFirewallRuleMapOutput added in v4.2.0 

func (i ResolverFirewallRuleMap) ToResolverFirewallRuleMapOutput() ResolverFirewallRuleMapOutput

func (ResolverFirewallRuleMap) ToResolverFirewallRuleMapOutputWithContext added in v4.2.0 

func (i ResolverFirewallRuleMap) ToResolverFirewallRuleMapOutputWithContext(ctx context.Context) ResolverFirewallRuleMapOutput

type ResolverFirewallRuleMapInput added in v4.2.0 

type ResolverFirewallRuleMapInput interface {
	pulumi.Input

	ToResolverFirewallRuleMapOutput() ResolverFirewallRuleMapOutput
	ToResolverFirewallRuleMapOutputWithContext(context.Context) ResolverFirewallRuleMapOutput
}

ResolverFirewallRuleMapInput is an input type that accepts ResolverFirewallRuleMap and ResolverFirewallRuleMapOutput values. You can construct a concrete instance of `ResolverFirewallRuleMapInput` via: 

ResolverFirewallRuleMap{ "key": ResolverFirewallRuleArgs{...} }

type ResolverFirewallRuleMapOutput added in v4.2.0 

type ResolverFirewallRuleMapOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleMapOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleMapOutput) ElementType() reflect.Type

func (ResolverFirewallRuleMapOutput) MapIndex added in v4.2.0 

func (o ResolverFirewallRuleMapOutput) MapIndex(k pulumi.StringInput) ResolverFirewallRuleOutput

func (ResolverFirewallRuleMapOutput) ToResolverFirewallRuleMapOutput added in v4.2.0 

func (o ResolverFirewallRuleMapOutput) ToResolverFirewallRuleMapOutput() ResolverFirewallRuleMapOutput

func (ResolverFirewallRuleMapOutput) ToResolverFirewallRuleMapOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleMapOutput) ToResolverFirewallRuleMapOutputWithContext(ctx context.Context) ResolverFirewallRuleMapOutput

type ResolverFirewallRuleOutput added in v4.2.0 

type ResolverFirewallRuleOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRuleOutput) ElementType added in v4.2.0 

func (ResolverFirewallRuleOutput) ElementType() reflect.Type

func (ResolverFirewallRuleOutput) ToResolverFirewallRuleOutput added in v4.2.0 

func (o ResolverFirewallRuleOutput) ToResolverFirewallRuleOutput() ResolverFirewallRuleOutput

func (ResolverFirewallRuleOutput) ToResolverFirewallRuleOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleOutput) ToResolverFirewallRuleOutputWithContext(ctx context.Context) ResolverFirewallRuleOutput

func (ResolverFirewallRuleOutput) ToResolverFirewallRulePtrOutput added in v4.2.0 

func (o ResolverFirewallRuleOutput) ToResolverFirewallRulePtrOutput() ResolverFirewallRulePtrOutput

func (ResolverFirewallRuleOutput) ToResolverFirewallRulePtrOutputWithContext added in v4.2.0 

func (o ResolverFirewallRuleOutput) ToResolverFirewallRulePtrOutputWithContext(ctx context.Context) ResolverFirewallRulePtrOutput

type ResolverFirewallRulePtrInput added in v4.2.0 

type ResolverFirewallRulePtrInput interface {
	pulumi.Input

	ToResolverFirewallRulePtrOutput() ResolverFirewallRulePtrOutput
	ToResolverFirewallRulePtrOutputWithContext(ctx context.Context) ResolverFirewallRulePtrOutput
}

type ResolverFirewallRulePtrOutput added in v4.2.0 

type ResolverFirewallRulePtrOutput struct{ *pulumi.OutputState }

func (ResolverFirewallRulePtrOutput) Elem added in v4.15.0 

func (o ResolverFirewallRulePtrOutput) Elem() ResolverFirewallRuleOutput

func (ResolverFirewallRulePtrOutput) ElementType added in v4.2.0 

func (ResolverFirewallRulePtrOutput) ElementType() reflect.Type

func (ResolverFirewallRulePtrOutput) ToResolverFirewallRulePtrOutput added in v4.2.0 

func (o ResolverFirewallRulePtrOutput) ToResolverFirewallRulePtrOutput() ResolverFirewallRulePtrOutput

func (ResolverFirewallRulePtrOutput) ToResolverFirewallRulePtrOutputWithContext added in v4.2.0 

func (o ResolverFirewallRulePtrOutput) ToResolverFirewallRulePtrOutputWithContext(ctx context.Context) ResolverFirewallRulePtrOutput

type ResolverFirewallRuleState added in v4.2.0 

type ResolverFirewallRuleState struct {
	// The action that DNS Firewall should take on a DNS query when it matches one of the domains in the rule's domain list. Valid values: `ALLOW`, `BLOCK`, `ALERT`.
	Action pulumi.StringPtrInput
	// The DNS record's type. This determines the format of the record value that you provided in BlockOverrideDomain. Value values: `CNAME`.
	BlockOverrideDnsType pulumi.StringPtrInput
	// The custom DNS record to send back in response to the query.
	BlockOverrideDomain pulumi.StringPtrInput
	// The recommended amount of time, in seconds, for the DNS resolver or web browser to cache the provided override record. Minimum value of 0. Maximum value of 604800.
	BlockOverrideTtl pulumi.IntPtrInput
	// The way that you want DNS Firewall to block the request. Valid values: `NODATA`, `NXDOMAIN`, `OVERRIDE`.
	BlockResponse pulumi.StringPtrInput
	// The ID of the domain list that you want to use in the rule.
	FirewallDomainListId pulumi.StringPtrInput
	// The unique identifier of the firewall rule group where you want to create the rule.
	FirewallRuleGroupId pulumi.StringPtrInput
	// A name that lets you identify the rule, to manage and use it.
	Name pulumi.StringPtrInput
	// The setting that determines the processing order of the rule in the rule group. DNS Firewall processes the rules in a rule group by order of priority, starting from the lowest setting.
	Priority pulumi.IntPtrInput
}

func (ResolverFirewallRuleState) ElementType added in v4.2.0 

func (ResolverFirewallRuleState) ElementType() reflect.Type

type ResolverQueryLogConfig 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Route 53 Resolver query logging configuration resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

func (*ResolverQueryLogConfig) ElementType() reflect.Type

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigOutput 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigOutputWithContext 

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

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutput 

func (i *ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (*ResolverQueryLogConfig) ToResolverQueryLogConfigPtrOutputWithContext 

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

type ResolverQueryLogConfigArgs 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a ResolverQueryLogConfig resource.

func (ResolverQueryLogConfigArgs) ElementType 

func (ResolverQueryLogConfigArgs) ElementType() reflect.Type

type ResolverQueryLogConfigArray 

type ResolverQueryLogConfigArray []ResolverQueryLogConfigInput

func (ResolverQueryLogConfigArray) ElementType 

func (ResolverQueryLogConfigArray) ElementType() reflect.Type

func (ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutput 

func (i ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutput() ResolverQueryLogConfigArrayOutput

func (ResolverQueryLogConfigArray) ToResolverQueryLogConfigArrayOutputWithContext 

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

type ResolverQueryLogConfigArrayInput 

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 

type ResolverQueryLogConfigArrayOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigArrayOutput) ElementType 

func (ResolverQueryLogConfigArrayOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigArrayOutput) Index 

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

func (ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutput 

func (o ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutput() ResolverQueryLogConfigArrayOutput

func (ResolverQueryLogConfigArrayOutput) ToResolverQueryLogConfigArrayOutputWithContext 

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

type ResolverQueryLogConfigAssociation 

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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

func (*ResolverQueryLogConfigAssociation) ElementType() reflect.Type

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationOutputWithContext 

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

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutput 

func (i *ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (*ResolverQueryLogConfigAssociation) ToResolverQueryLogConfigAssociationPtrOutputWithContext 

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

type ResolverQueryLogConfigAssociationArgs 

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 

func (ResolverQueryLogConfigAssociationArgs) ElementType() reflect.Type

type ResolverQueryLogConfigAssociationArray 

type ResolverQueryLogConfigAssociationArray []ResolverQueryLogConfigAssociationInput

func (ResolverQueryLogConfigAssociationArray) ElementType 

func (ResolverQueryLogConfigAssociationArray) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutput 

func (i ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutput() ResolverQueryLogConfigAssociationArrayOutput

func (ResolverQueryLogConfigAssociationArray) ToResolverQueryLogConfigAssociationArrayOutputWithContext 

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

type ResolverQueryLogConfigAssociationArrayInput 

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 

type ResolverQueryLogConfigAssociationArrayOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationArrayOutput) ElementType 

func (ResolverQueryLogConfigAssociationArrayOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationArrayOutput) Index 

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

func (ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutput 

func (o ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutput() ResolverQueryLogConfigAssociationArrayOutput

func (ResolverQueryLogConfigAssociationArrayOutput) ToResolverQueryLogConfigAssociationArrayOutputWithContext 

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

type ResolverQueryLogConfigAssociationInput 

type ResolverQueryLogConfigAssociationInput interface {
	pulumi.Input

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

type ResolverQueryLogConfigAssociationMap 

type ResolverQueryLogConfigAssociationMap map[string]ResolverQueryLogConfigAssociationInput

func (ResolverQueryLogConfigAssociationMap) ElementType 

func (ResolverQueryLogConfigAssociationMap) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutput 

func (i ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutput() ResolverQueryLogConfigAssociationMapOutput

func (ResolverQueryLogConfigAssociationMap) ToResolverQueryLogConfigAssociationMapOutputWithContext 

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

type ResolverQueryLogConfigAssociationMapInput 

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 

type ResolverQueryLogConfigAssociationMapOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationMapOutput) ElementType 

func (ResolverQueryLogConfigAssociationMapOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationMapOutput) MapIndex 

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

func (ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutput 

func (o ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutput() ResolverQueryLogConfigAssociationMapOutput

func (ResolverQueryLogConfigAssociationMapOutput) ToResolverQueryLogConfigAssociationMapOutputWithContext 

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

type ResolverQueryLogConfigAssociationOutput 

type ResolverQueryLogConfigAssociationOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationOutput) ElementType 

func (ResolverQueryLogConfigAssociationOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutput() ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationOutputWithContext 

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

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutput 

func (o ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (ResolverQueryLogConfigAssociationOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext 

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

type ResolverQueryLogConfigAssociationPtrInput 

type ResolverQueryLogConfigAssociationPtrInput interface {
	pulumi.Input

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

type ResolverQueryLogConfigAssociationPtrOutput 

type ResolverQueryLogConfigAssociationPtrOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigAssociationPtrOutput) Elem added in v4.15.0 

func (o ResolverQueryLogConfigAssociationPtrOutput) Elem() ResolverQueryLogConfigAssociationOutput

func (ResolverQueryLogConfigAssociationPtrOutput) ElementType 

func (ResolverQueryLogConfigAssociationPtrOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutput 

func (o ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutput() ResolverQueryLogConfigAssociationPtrOutput

func (ResolverQueryLogConfigAssociationPtrOutput) ToResolverQueryLogConfigAssociationPtrOutputWithContext 

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

type ResolverQueryLogConfigAssociationState 

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 

func (ResolverQueryLogConfigAssociationState) ElementType() reflect.Type

type ResolverQueryLogConfigInput 

type ResolverQueryLogConfigInput interface {
	pulumi.Input

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

type ResolverQueryLogConfigMap 

type ResolverQueryLogConfigMap map[string]ResolverQueryLogConfigInput

func (ResolverQueryLogConfigMap) ElementType 

func (ResolverQueryLogConfigMap) ElementType() reflect.Type

func (ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutput 

func (i ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutput() ResolverQueryLogConfigMapOutput

func (ResolverQueryLogConfigMap) ToResolverQueryLogConfigMapOutputWithContext 

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

type ResolverQueryLogConfigMapInput 

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 

type ResolverQueryLogConfigMapOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigMapOutput) ElementType 

func (ResolverQueryLogConfigMapOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigMapOutput) MapIndex 

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

func (ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutput 

func (o ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutput() ResolverQueryLogConfigMapOutput

func (ResolverQueryLogConfigMapOutput) ToResolverQueryLogConfigMapOutputWithContext 

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

type ResolverQueryLogConfigOutput 

type ResolverQueryLogConfigOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigOutput) ElementType 

func (ResolverQueryLogConfigOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutput() ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigOutputWithContext 

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

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutput 

func (o ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (ResolverQueryLogConfigOutput) ToResolverQueryLogConfigPtrOutputWithContext 

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

type ResolverQueryLogConfigPtrInput 

type ResolverQueryLogConfigPtrInput interface {
	pulumi.Input

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

type ResolverQueryLogConfigPtrOutput 

type ResolverQueryLogConfigPtrOutput struct{ *pulumi.OutputState }

func (ResolverQueryLogConfigPtrOutput) Elem added in v4.15.0 

func (o ResolverQueryLogConfigPtrOutput) Elem() ResolverQueryLogConfigOutput

func (ResolverQueryLogConfigPtrOutput) ElementType 

func (ResolverQueryLogConfigPtrOutput) ElementType() reflect.Type

func (ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutput 

func (o ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutput() ResolverQueryLogConfigPtrOutput

func (ResolverQueryLogConfigPtrOutput) ToResolverQueryLogConfigPtrOutputWithContext 

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

type ResolverQueryLogConfigState 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (ResolverQueryLogConfigState) ElementType 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// 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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*ResolverRule) ElementType() reflect.Type

func (*ResolverRule) ToResolverRuleOutput 

func (i *ResolverRule) ToResolverRuleOutput() ResolverRuleOutput

func (*ResolverRule) ToResolverRuleOutputWithContext 

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

func (*ResolverRule) ToResolverRulePtrOutput 

func (i *ResolverRule) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (*ResolverRule) ToResolverRulePtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	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 

type ResolverRuleArray []ResolverRuleInput

func (ResolverRuleArray) ElementType 

func (ResolverRuleArray) ElementType() reflect.Type

func (ResolverRuleArray) ToResolverRuleArrayOutput 

func (i ResolverRuleArray) ToResolverRuleArrayOutput() ResolverRuleArrayOutput

func (ResolverRuleArray) ToResolverRuleArrayOutputWithContext 

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

type ResolverRuleArrayInput 

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 

type ResolverRuleArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleArrayOutput) ElementType 

func (ResolverRuleArrayOutput) ElementType() reflect.Type

func (ResolverRuleArrayOutput) Index 

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

func (ResolverRuleArrayOutput) ToResolverRuleArrayOutput 

func (o ResolverRuleArrayOutput) ToResolverRuleArrayOutput() ResolverRuleArrayOutput

func (ResolverRuleArrayOutput) ToResolverRuleArrayOutputWithContext 

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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*ResolverRuleAssociation) ElementType() reflect.Type

func (*ResolverRuleAssociation) ToResolverRuleAssociationOutput 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (*ResolverRuleAssociation) ToResolverRuleAssociationOutputWithContext 

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

func (*ResolverRuleAssociation) ToResolverRuleAssociationPtrOutput 

func (i *ResolverRuleAssociation) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (*ResolverRuleAssociation) ToResolverRuleAssociationPtrOutputWithContext 

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 

type ResolverRuleAssociationArray []ResolverRuleAssociationInput

func (ResolverRuleAssociationArray) ElementType 

func (ResolverRuleAssociationArray) ElementType() reflect.Type

func (ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutput 

func (i ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutput() ResolverRuleAssociationArrayOutput

func (ResolverRuleAssociationArray) ToResolverRuleAssociationArrayOutputWithContext 

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

type ResolverRuleAssociationArrayInput 

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 

type ResolverRuleAssociationArrayOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationArrayOutput) ElementType 

func (ResolverRuleAssociationArrayOutput) ElementType() reflect.Type

func (ResolverRuleAssociationArrayOutput) Index 

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

func (ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutput 

func (o ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutput() ResolverRuleAssociationArrayOutput

func (ResolverRuleAssociationArrayOutput) ToResolverRuleAssociationArrayOutputWithContext 

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

type ResolverRuleAssociationInput 

type ResolverRuleAssociationInput interface {
	pulumi.Input

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

type ResolverRuleAssociationMap 

type ResolverRuleAssociationMap map[string]ResolverRuleAssociationInput

func (ResolverRuleAssociationMap) ElementType 

func (ResolverRuleAssociationMap) ElementType() reflect.Type

func (ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutput 

func (i ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutput() ResolverRuleAssociationMapOutput

func (ResolverRuleAssociationMap) ToResolverRuleAssociationMapOutputWithContext 

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

type ResolverRuleAssociationMapInput 

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 

type ResolverRuleAssociationMapOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationMapOutput) ElementType 

func (ResolverRuleAssociationMapOutput) ElementType() reflect.Type

func (ResolverRuleAssociationMapOutput) MapIndex 

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

func (ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutput 

func (o ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutput() ResolverRuleAssociationMapOutput

func (ResolverRuleAssociationMapOutput) ToResolverRuleAssociationMapOutputWithContext 

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

type ResolverRuleAssociationOutput 

type ResolverRuleAssociationOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationOutput) ElementType 

func (ResolverRuleAssociationOutput) ElementType() reflect.Type

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationOutput() ResolverRuleAssociationOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationOutputWithContext 

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

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutput 

func (o ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (ResolverRuleAssociationOutput) ToResolverRuleAssociationPtrOutputWithContext 

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

type ResolverRuleAssociationPtrInput 

type ResolverRuleAssociationPtrInput interface {
	pulumi.Input

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

type ResolverRuleAssociationPtrOutput 

type ResolverRuleAssociationPtrOutput struct{ *pulumi.OutputState }

func (ResolverRuleAssociationPtrOutput) Elem added in v4.15.0 

func (o ResolverRuleAssociationPtrOutput) Elem() ResolverRuleAssociationOutput

func (ResolverRuleAssociationPtrOutput) ElementType 

func (ResolverRuleAssociationPtrOutput) ElementType() reflect.Type

func (ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutput 

func (o ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutput() ResolverRuleAssociationPtrOutput

func (ResolverRuleAssociationPtrOutput) ToResolverRuleAssociationPtrOutputWithContext 

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 

type ResolverRuleInput interface {
	pulumi.Input

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

type ResolverRuleMap 

type ResolverRuleMap map[string]ResolverRuleInput

func (ResolverRuleMap) ElementType 

func (ResolverRuleMap) ElementType() reflect.Type

func (ResolverRuleMap) ToResolverRuleMapOutput 

func (i ResolverRuleMap) ToResolverRuleMapOutput() ResolverRuleMapOutput

func (ResolverRuleMap) ToResolverRuleMapOutputWithContext 

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

type ResolverRuleMapInput 

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 

type ResolverRuleMapOutput struct{ *pulumi.OutputState }

func (ResolverRuleMapOutput) ElementType 

func (ResolverRuleMapOutput) ElementType() reflect.Type

func (ResolverRuleMapOutput) MapIndex 

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

func (ResolverRuleMapOutput) ToResolverRuleMapOutput 

func (o ResolverRuleMapOutput) ToResolverRuleMapOutput() ResolverRuleMapOutput

func (ResolverRuleMapOutput) ToResolverRuleMapOutputWithContext 

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

type ResolverRuleOutput 

type ResolverRuleOutput struct{ *pulumi.OutputState }

func (ResolverRuleOutput) ElementType 

func (ResolverRuleOutput) ElementType() reflect.Type

func (ResolverRuleOutput) ToResolverRuleOutput 

func (o ResolverRuleOutput) ToResolverRuleOutput() ResolverRuleOutput

func (ResolverRuleOutput) ToResolverRuleOutputWithContext 

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

func (ResolverRuleOutput) ToResolverRulePtrOutput 

func (o ResolverRuleOutput) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (ResolverRuleOutput) ToResolverRulePtrOutputWithContext 

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

type ResolverRulePtrInput 

type ResolverRulePtrInput interface {
	pulumi.Input

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

type ResolverRulePtrOutput 

type ResolverRulePtrOutput struct{ *pulumi.OutputState }

func (ResolverRulePtrOutput) Elem added in v4.15.0 

func (o ResolverRulePtrOutput) Elem() ResolverRuleOutput

func (ResolverRulePtrOutput) ElementType 

func (ResolverRulePtrOutput) ElementType() reflect.Type

func (ResolverRulePtrOutput) ToResolverRulePtrOutput 

func (o ResolverRulePtrOutput) ToResolverRulePtrOutput() ResolverRulePtrOutput

func (ResolverRulePtrOutput) ToResolverRulePtrOutputWithContext 

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. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll 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 

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 different account to be associated with a local Route53 Hosted Zone.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/providers"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

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 

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 

func (*VpcAssociationAuthorization) ElementType() reflect.Type

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationOutputWithContext 

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

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutput 

func (i *VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (*VpcAssociationAuthorization) ToVpcAssociationAuthorizationPtrOutputWithContext 

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

type VpcAssociationAuthorizationArgs 

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 

func (VpcAssociationAuthorizationArgs) ElementType() reflect.Type

type VpcAssociationAuthorizationArray 

type VpcAssociationAuthorizationArray []VpcAssociationAuthorizationInput

func (VpcAssociationAuthorizationArray) ElementType 

func (VpcAssociationAuthorizationArray) ElementType() reflect.Type

func (VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutput 

func (i VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutput() VpcAssociationAuthorizationArrayOutput

func (VpcAssociationAuthorizationArray) ToVpcAssociationAuthorizationArrayOutputWithContext 

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

type VpcAssociationAuthorizationArrayInput 

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 

type VpcAssociationAuthorizationArrayOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationArrayOutput) ElementType 

func (VpcAssociationAuthorizationArrayOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationArrayOutput) Index 

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

func (VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutput 

func (o VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutput() VpcAssociationAuthorizationArrayOutput

func (VpcAssociationAuthorizationArrayOutput) ToVpcAssociationAuthorizationArrayOutputWithContext 

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

type VpcAssociationAuthorizationInput 

type VpcAssociationAuthorizationInput interface {
	pulumi.Input

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

type VpcAssociationAuthorizationMap 

type VpcAssociationAuthorizationMap map[string]VpcAssociationAuthorizationInput

func (VpcAssociationAuthorizationMap) ElementType 

func (VpcAssociationAuthorizationMap) ElementType() reflect.Type

func (VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutput 

func (i VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutput() VpcAssociationAuthorizationMapOutput

func (VpcAssociationAuthorizationMap) ToVpcAssociationAuthorizationMapOutputWithContext 

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

type VpcAssociationAuthorizationMapInput 

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 

type VpcAssociationAuthorizationMapOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationMapOutput) ElementType 

func (VpcAssociationAuthorizationMapOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationMapOutput) MapIndex 

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

func (VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutput 

func (o VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutput() VpcAssociationAuthorizationMapOutput

func (VpcAssociationAuthorizationMapOutput) ToVpcAssociationAuthorizationMapOutputWithContext 

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

type VpcAssociationAuthorizationOutput 

type VpcAssociationAuthorizationOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationOutput) ElementType 

func (VpcAssociationAuthorizationOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutput() VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationOutputWithContext 

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

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutput 

func (o VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (VpcAssociationAuthorizationOutput) ToVpcAssociationAuthorizationPtrOutputWithContext 

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

type VpcAssociationAuthorizationPtrInput 

type VpcAssociationAuthorizationPtrInput interface {
	pulumi.Input

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

type VpcAssociationAuthorizationPtrOutput 

type VpcAssociationAuthorizationPtrOutput struct{ *pulumi.OutputState }

func (VpcAssociationAuthorizationPtrOutput) Elem added in v4.15.0 

func (o VpcAssociationAuthorizationPtrOutput) Elem() VpcAssociationAuthorizationOutput

func (VpcAssociationAuthorizationPtrOutput) ElementType 

func (VpcAssociationAuthorizationPtrOutput) ElementType() reflect.Type

func (VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutput 

func (o VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutput() VpcAssociationAuthorizationPtrOutput

func (VpcAssociationAuthorizationPtrOutput) ToVpcAssociationAuthorizationPtrOutputWithContext 

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

type VpcAssociationAuthorizationState 

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 

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"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// 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. For managing Domain Name System Security Extensions (DNSSEC), see the `route53.KeySigningKey` and `route53.HostedZoneDnsSec` resources.

## Example Usage ### Public Zone

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 

func (*Zone) ElementType() reflect.Type

func (*Zone) ToZoneOutput 

func (i *Zone) ToZoneOutput() ZoneOutput

func (*Zone) ToZoneOutputWithContext 

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

func (*Zone) ToZonePtrOutput 

func (i *Zone) ToZonePtrOutput() ZonePtrOutput

func (*Zone) ToZonePtrOutputWithContext 

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 

type ZoneArray []ZoneInput

func (ZoneArray) ElementType 

func (ZoneArray) ElementType() reflect.Type

func (ZoneArray) ToZoneArrayOutput 

func (i ZoneArray) ToZoneArrayOutput() ZoneArrayOutput

func (ZoneArray) ToZoneArrayOutputWithContext 

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

type ZoneArrayInput 

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 

type ZoneArrayOutput struct{ *pulumi.OutputState }

func (ZoneArrayOutput) ElementType 

func (ZoneArrayOutput) ElementType() reflect.Type

func (ZoneArrayOutput) Index 

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

func (ZoneArrayOutput) ToZoneArrayOutput 

func (o ZoneArrayOutput) ToZoneArrayOutput() ZoneArrayOutput

func (ZoneArrayOutput) ToZoneArrayOutputWithContext 

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/v4/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/route53"
"github.com/pulumi/pulumi/sdk/v3/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 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 

func (*ZoneAssociation) ElementType() reflect.Type

func (*ZoneAssociation) ToZoneAssociationOutput 

func (i *ZoneAssociation) ToZoneAssociationOutput() ZoneAssociationOutput

func (*ZoneAssociation) ToZoneAssociationOutputWithContext 

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

func (*ZoneAssociation) ToZoneAssociationPtrOutput 

func (i *ZoneAssociation) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (*ZoneAssociation) ToZoneAssociationPtrOutputWithContext 

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 

type ZoneAssociationArray []ZoneAssociationInput

func (ZoneAssociationArray) ElementType 

func (ZoneAssociationArray) ElementType() reflect.Type

func (ZoneAssociationArray) ToZoneAssociationArrayOutput 

func (i ZoneAssociationArray) ToZoneAssociationArrayOutput() ZoneAssociationArrayOutput

func (ZoneAssociationArray) ToZoneAssociationArrayOutputWithContext 

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

type ZoneAssociationArrayInput 

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 

type ZoneAssociationArrayOutput struct{ *pulumi.OutputState }

func (ZoneAssociationArrayOutput) ElementType 

func (ZoneAssociationArrayOutput) ElementType() reflect.Type

func (ZoneAssociationArrayOutput) Index 

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

func (ZoneAssociationArrayOutput) ToZoneAssociationArrayOutput 

func (o ZoneAssociationArrayOutput) ToZoneAssociationArrayOutput() ZoneAssociationArrayOutput

func (ZoneAssociationArrayOutput) ToZoneAssociationArrayOutputWithContext 

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

type ZoneAssociationInput 

type ZoneAssociationInput interface {
	pulumi.Input

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

type ZoneAssociationMap 

type ZoneAssociationMap map[string]ZoneAssociationInput

func (ZoneAssociationMap) ElementType 

func (ZoneAssociationMap) ElementType() reflect.Type

func (ZoneAssociationMap) ToZoneAssociationMapOutput 

func (i ZoneAssociationMap) ToZoneAssociationMapOutput() ZoneAssociationMapOutput

func (ZoneAssociationMap) ToZoneAssociationMapOutputWithContext 

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

type ZoneAssociationMapInput 

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 

type ZoneAssociationMapOutput struct{ *pulumi.OutputState }

func (ZoneAssociationMapOutput) ElementType 

func (ZoneAssociationMapOutput) ElementType() reflect.Type

func (ZoneAssociationMapOutput) MapIndex 

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

func (ZoneAssociationMapOutput) ToZoneAssociationMapOutput 

func (o ZoneAssociationMapOutput) ToZoneAssociationMapOutput() ZoneAssociationMapOutput

func (ZoneAssociationMapOutput) ToZoneAssociationMapOutputWithContext 

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

type ZoneAssociationOutput 

type ZoneAssociationOutput struct{ *pulumi.OutputState }

func (ZoneAssociationOutput) ElementType 

func (ZoneAssociationOutput) ElementType() reflect.Type

func (ZoneAssociationOutput) ToZoneAssociationOutput 

func (o ZoneAssociationOutput) ToZoneAssociationOutput() ZoneAssociationOutput

func (ZoneAssociationOutput) ToZoneAssociationOutputWithContext 

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

func (ZoneAssociationOutput) ToZoneAssociationPtrOutput 

func (o ZoneAssociationOutput) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (ZoneAssociationOutput) ToZoneAssociationPtrOutputWithContext 

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

type ZoneAssociationPtrInput 

type ZoneAssociationPtrInput interface {
	pulumi.Input

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

type ZoneAssociationPtrOutput 

type ZoneAssociationPtrOutput struct{ *pulumi.OutputState }

func (ZoneAssociationPtrOutput) Elem added in v4.15.0 

func (o ZoneAssociationPtrOutput) Elem() ZoneAssociationOutput

func (ZoneAssociationPtrOutput) ElementType 

func (ZoneAssociationPtrOutput) ElementType() reflect.Type

func (ZoneAssociationPtrOutput) ToZoneAssociationPtrOutput 

func (o ZoneAssociationPtrOutput) ToZoneAssociationPtrOutput() ZoneAssociationPtrOutput

func (ZoneAssociationPtrOutput) ToZoneAssociationPtrOutputWithContext 

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 

type ZoneInput interface {
	pulumi.Input

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

type ZoneMap 

type ZoneMap map[string]ZoneInput

func (ZoneMap) ElementType 

func (ZoneMap) ElementType() reflect.Type

func (ZoneMap) ToZoneMapOutput 

func (i ZoneMap) ToZoneMapOutput() ZoneMapOutput

func (ZoneMap) ToZoneMapOutputWithContext 

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

type ZoneMapInput 

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 

type ZoneMapOutput struct{ *pulumi.OutputState }

func (ZoneMapOutput) ElementType 

func (ZoneMapOutput) ElementType() reflect.Type

func (ZoneMapOutput) MapIndex 

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

func (ZoneMapOutput) ToZoneMapOutput 

func (o ZoneMapOutput) ToZoneMapOutput() ZoneMapOutput

func (ZoneMapOutput) ToZoneMapOutputWithContext 

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

type ZoneOutput 

type ZoneOutput struct{ *pulumi.OutputState }

func (ZoneOutput) ElementType 

func (ZoneOutput) ElementType() reflect.Type

func (ZoneOutput) ToZoneOutput 

func (o ZoneOutput) ToZoneOutput() ZoneOutput

func (ZoneOutput) ToZoneOutputWithContext 

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

func (ZoneOutput) ToZonePtrOutput 

func (o ZoneOutput) ToZonePtrOutput() ZonePtrOutput

func (ZoneOutput) ToZonePtrOutputWithContext 

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

type ZonePtrInput 

type ZonePtrInput interface {
	pulumi.Input

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

type ZonePtrOutput 

type ZonePtrOutput struct{ *pulumi.OutputState }

func (ZonePtrOutput) Elem added in v4.15.0 

func (o ZonePtrOutput) Elem() ZoneOutput

func (ZonePtrOutput) ElementType 

func (ZonePtrOutput) ElementType() reflect.Type

func (ZonePtrOutput) ToZonePtrOutput 

func (o ZonePtrOutput) ToZonePtrOutput() ZonePtrOutput

func (ZonePtrOutput) ToZonePtrOutputWithContext 

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
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll 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.