@propulsionworks/cloudformation 0.0.2 → 0.1.0

package/out/exports/resources.generated/aws-route53recoverycontrol-cluster.d.ts

@@ -0,0 +1,35 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryControlCluster = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryControl::Cluster", Route53RecoveryControlClusterProps, Route53RecoveryControlClusterAttribs>;
+/**
+ * Creates a cluster in Amazon Route 53 Application Recovery Controller. A cluster is a set of redundant Regional endpoints that you can run Route 53 ARC API calls against to update or get the state of one or more routing controls.
+ */
+export type Route53RecoveryControlClusterProps = {
+    /**
+     * Name of the cluster. You can use any non-white space character in the name except the following: & > < ' (single quote) " (double quote) ; (semicolon).
+     * @minLength 1
+     * @maxLength 64
+     */
+    Name: string;
+    /**
+     * The network-type can either be IPV4 or DUALSTACK.
+     */
+    NetworkType?: "IPV4" | "DUALSTACK" | undefined;
+    /**
+     * The tags associated with the cluster.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryControlClusterAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the cluster.
+     * @minLength 1
+     * @maxLength 2048
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    ClusterArn: string;
+    /**
+     * The deployment status of the cluster. Status can be one of the following: PENDING, DEPLOYED, PENDING_DELETION.
+     */
+    Status: "PENDING" | "DEPLOYED" | "PENDING_DELETION";
+};
+//# sourceMappingURL=aws-route53recoverycontrol-cluster.d.ts.map

package/out/exports/resources.generated/aws-route53recoverycontrol-controlpanel.d.ts

@@ -0,0 +1,42 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryControlControlPanel = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryControl::ControlPanel", Route53RecoveryControlControlPanelProps, Route53RecoveryControlControlPanelAttribs>;
+/**
+ * Creates a new control panel in Amazon Route 53 Application Recovery Controller. A control panel represents a group of routing controls that can be changed together in a single transaction. You can use a control panel to centrally view the operational status of applications across your organization, and trigger multi-app failovers in a single transaction, for example, to fail over from one AWS Region (cell) to another.
+ */
+export type Route53RecoveryControlControlPanelProps = {
+    /**
+     * The Amazon Resource Name (ARN) of the cluster for the control panel.
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    ClusterArn?: string | undefined;
+    /**
+     * The name of the control panel. You can use any non-white space character in the name.
+     * @minLength 1
+     * @maxLength 64
+     */
+    Name: string;
+    /**
+     * The tags associated with the control panel.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryControlControlPanelAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the control panel.
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    ControlPanelArn: string;
+    /**
+     * The boolean flag that is set to true for the default control panel in the cluster.
+     */
+    DefaultControlPanel: boolean;
+    /**
+     * The number of routing controls in the control panel.
+     */
+    RoutingControlCount: number;
+    /**
+     * The deployment status of control panel. Status can be one of the following: PENDING, DEPLOYED, PENDING_DELETION.
+     */
+    Status: "PENDING" | "DEPLOYED" | "PENDING_DELETION";
+};
+//# sourceMappingURL=aws-route53recoverycontrol-controlpanel.d.ts.map

package/out/exports/resources.generated/aws-route53recoverycontrol-routingcontrol.d.ts

@@ -0,0 +1,37 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type Route53RecoveryControlRoutingControl = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryControl::RoutingControl", Route53RecoveryControlRoutingControlProps, Route53RecoveryControlRoutingControlAttribs>;
+/**
+ * Creates a routing control in Amazon Route 53 Application Recovery Controller. Routing control states are maintained on the highly reliable cluster data plane.
+ *
+ * To get or update the state of the routing control, you must specify a cluster endpoint, which is an endpoint URL and an AWS Region. For more information, see [Code examples](https://docs.aws.amazon.com/r53recovery/latest/dg/service_code_examples.html) in the Amazon Route 53 Application Recovery Controller Developer Guide.
+ */
+export type Route53RecoveryControlRoutingControlProps = {
+    /**
+     * The Amazon Resource Name (ARN) of the cluster that hosts the routing control.
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    ClusterArn?: string | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the control panel that includes the routing control.
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    ControlPanelArn?: string | undefined;
+    /**
+     * The name of the routing control. You can use any non-white space character in the name.
+     * @minLength 1
+     * @maxLength 64
+     */
+    Name: string;
+};
+export type Route53RecoveryControlRoutingControlAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the routing control.
+     * @pattern ^[A-Za-z0-9:\/_-]*$
+     */
+    RoutingControlArn: string;
+    /**
+     * The deployment status of the routing control. Status can be one of the following: PENDING, DEPLOYED, PENDING_DELETION.
+     */
+    Status: "PENDING" | "DEPLOYED" | "PENDING_DELETION";
+};
+//# sourceMappingURL=aws-route53recoverycontrol-routingcontrol.d.ts.map

package/out/exports/resources.generated/aws-route53recoverycontrol-safetyrule.d.ts

@@ -0,0 +1,132 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryControlSafetyRule = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryControl::SafetyRule", Route53RecoveryControlSafetyRuleProps, Route53RecoveryControlSafetyRuleAttribs>;
+/**
+ * Creates a safety rule in a control panel in Amazon Route 53 Application Recovery Controller. Safety rules in Amazon Route 53 Application Recovery Controller let you add safeguards around changing routing control states, and enabling and disabling routing controls, to help prevent unwanted outcomes. Note that the name of a safety rule must be unique within a control panel.
+ *
+ * There are two types of safety rules in Route 53 ARC: assertion rules and gating rules.
+ *
+ * Assertion rule: An assertion rule enforces that, when you change a routing control state, certain criteria are met. For example, the criteria might be that at least one routing control state is `On` after the transaction completes so that traffic continues to be directed to at least one cell for the application. This prevents a fail-open scenario.
+ *
+ * Gating rule: A gating rule lets you configure a gating routing control as an overall on-off switch for a group of routing controls. Or, you can configure more complex gating scenarios, for example, by configuring multiple gating routing controls.
+ *
+ * For more information, see [Safety rules](https://docs.aws.amazon.com/r53recovery/latest/dg/routing-control.safety-rules.html) in the Amazon Route 53 Application Recovery Controller Developer Guide.
+ */
+export type Route53RecoveryControlSafetyRuleProps = {
+    /**
+     * An assertion rule enforces that, when you change a routing control state, that the criteria that you set in the rule configuration is met. Otherwise, the change to the routing control is not accepted. For example, the criteria might be that at least one routing control state is `On` after the transaction so that traffic continues to flow to at least one cell for the application. This ensures that you avoid a fail-open scenario.
+     */
+    AssertionRule: AssertionRule;
+    /**
+     * The Amazon Resource Name (ARN) of the control panel.
+     */
+    ControlPanelArn: string;
+    /**
+     * A gating rule verifies that a gating routing control or set of gating routing controls, evaluates as true, based on a rule configuration that you specify, which allows a set of routing control state changes to complete.
+     *
+     * For example, if you specify one gating routing control and you set the `Type` in the rule configuration to `OR` , that indicates that you must set the gating routing control to `On` for the rule to evaluate as true; that is, for the gating control switch to be On. When you do that, then you can update the routing control states for the target routing controls that you specify in the gating rule.
+     */
+    GatingRule?: GatingRule | undefined;
+    /**
+     * The name of the assertion rule. The name must be unique within a control panel. You can use any non-white space character in the name except the following: & > < ' (single quote) " (double quote) ; (semicolon)
+     */
+    Name: string;
+    /**
+     * The criteria that you set for specific assertion controls (routing controls) that designate how many control states must be `ON` as the result of a transaction. For example, if you have three assertion controls, you might specify `ATLEAST 2` for your rule configuration. This means that at least two assertion controls must be `ON` , so that at least two AWS Regions have traffic flowing to them.
+     */
+    RuleConfig: RuleConfig;
+    /**
+     * The tags associated with the safety rule.
+     */
+    Tags?: Tag[] | undefined;
+} | {
+    /**
+     * An assertion rule enforces that, when you change a routing control state, that the criteria that you set in the rule configuration is met. Otherwise, the change to the routing control is not accepted. For example, the criteria might be that at least one routing control state is `On` after the transaction so that traffic continues to flow to at least one cell for the application. This ensures that you avoid a fail-open scenario.
+     */
+    AssertionRule?: AssertionRule | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the control panel.
+     */
+    ControlPanelArn: string;
+    /**
+     * A gating rule verifies that a gating routing control or set of gating routing controls, evaluates as true, based on a rule configuration that you specify, which allows a set of routing control state changes to complete.
+     *
+     * For example, if you specify one gating routing control and you set the `Type` in the rule configuration to `OR` , that indicates that you must set the gating routing control to `On` for the rule to evaluate as true; that is, for the gating control switch to be On. When you do that, then you can update the routing control states for the target routing controls that you specify in the gating rule.
+     */
+    GatingRule: GatingRule;
+    /**
+     * The name of the assertion rule. The name must be unique within a control panel. You can use any non-white space character in the name except the following: & > < ' (single quote) " (double quote) ; (semicolon)
+     */
+    Name: string;
+    /**
+     * The criteria that you set for specific assertion controls (routing controls) that designate how many control states must be `ON` as the result of a transaction. For example, if you have three assertion controls, you might specify `ATLEAST 2` for your rule configuration. This means that at least two assertion controls must be `ON` , so that at least two AWS Regions have traffic flowing to them.
+     */
+    RuleConfig: RuleConfig;
+    /**
+     * The tags associated with the safety rule.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryControlSafetyRuleAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the safety rule.
+     */
+    SafetyRuleArn: string;
+    /**
+     * The deployment status of the safety rule. Status can be one of the following: PENDING, DEPLOYED, PENDING_DELETION.
+     */
+    Status: "PENDING" | "DEPLOYED" | "PENDING_DELETION";
+};
+/**
+ * An assertion rule enforces that, when you change a routing control state, that the criteria that you set in the rule configuration is met. Otherwise, the change to the routing control is not accepted. For example, the criteria might be that at least one routing control state is `On` after the transaction so that traffic continues to flow to at least one cell for the application. This ensures that you avoid a fail-open scenario.
+ */
+export type AssertionRule = {
+    /**
+     * The routing controls that are part of transactions that are evaluated to determine if a request to change a routing control state is allowed. For example, you might include three routing controls, one for each of three AWS Regions.
+     */
+    AssertedControls: string[];
+    /**
+     * An evaluation period, in milliseconds (ms), during which any request against the target routing controls will fail. This helps prevent flapping of state. The wait period is 5000 ms by default, but you can choose a custom value.
+     */
+    WaitPeriodMs: number;
+};
+/**
+ * A gating rule verifies that a gating routing control or set of gating routing controls, evaluates as true, based on a rule configuration that you specify, which allows a set of routing control state changes to complete.
+ *
+ * For example, if you specify one gating routing control and you set the `Type` in the rule configuration to `OR` , that indicates that you must set the gating routing control to `On` for the rule to evaluate as true; that is, for the gating control switch to be On. When you do that, then you can update the routing control states for the target routing controls that you specify in the gating rule.
+ */
+export type GatingRule = {
+    /**
+     * An array of gating routing control Amazon Resource Names (ARNs). For a simple on-off switch, specify the ARN for one routing control. The gating routing controls are evaluated by the rule configuration that you specify to determine if the target routing control states can be changed.
+     */
+    GatingControls: string[];
+    /**
+     * An array of target routing control Amazon Resource Names (ARNs) for which the states can only be updated if the rule configuration that you specify evaluates to true for the gating routing control. As a simple example, if you have a single gating control, it acts as an overall on-off switch for a set of target routing controls. You can use this to manually override automated failover, for example.
+     */
+    TargetControls: string[];
+    /**
+     * An evaluation period, in milliseconds (ms), during which any request against the target routing controls will fail. This helps prevent flapping of state. The wait period is 5000 ms by default, but you can choose a custom value.
+     */
+    WaitPeriodMs: number;
+};
+/**
+ * The rule configuration for an assertion rule. That is, the criteria that you set for specific assertion controls (routing controls) that specify how many controls must be enabled after a transaction completes.
+ */
+export type RuleConfig = {
+    /**
+     * Logical negation of the rule. If the rule would usually evaluate true, it's evaluated as false, and vice versa.
+     */
+    Inverted: boolean;
+    /**
+     * The value of N, when you specify an `ATLEAST` rule type. That is, `Threshold` is the number of controls that must be set when you specify an `ATLEAST` type.
+     */
+    Threshold: number;
+    /**
+     * A rule can be one of the following: `ATLEAST` , `AND` , or `OR` .
+     */
+    Type: RuleType;
+};
+/**
+ * A rule can be one of the following: ATLEAST, AND, or OR.
+ */
+export type RuleType = "AND" | "OR" | "ATLEAST";
+//# sourceMappingURL=aws-route53recoverycontrol-safetyrule.d.ts.map

package/out/exports/resources.generated/aws-route53recoveryreadiness-cell.d.ts

@@ -0,0 +1,39 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryReadinessCell = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryReadiness::Cell", Route53RecoveryReadinessCellProps, Route53RecoveryReadinessCellAttribs>;
+/**
+ * Creates a cell in recovery group in Amazon Route 53 Application Recovery Controller. A cell in Route 53 ARC represents replicas or independent units of failover in your application. It groups within it all the AWS resources that are necessary for your application to run independently. Typically, you would have define one set of resources in a primary cell and another set in a standby cell in your recovery group.
+ *
+ * After you set up the cells for your application, you can create readiness checks in Route 53 ARC to continually audit readiness for AWS resource quotas, capacity, network routing policies, and other predefined rules.
+ *
+ * You can set up notifications about changes that would affect your ability to fail over to a replica and recover. However, you should make decisions about whether to fail away from or to a replica based on your monitoring and health check systems. You should consider readiness checks as a complementary service to those systems.
+ *
+ * Route 53 ARC Readiness supports us-east-1 and us-west-2 AWS Regions only.
+ */
+export type Route53RecoveryReadinessCellProps = {
+    /**
+     * The name of the cell to create.
+     * @maxLength 64
+     * @pattern [a-zA-Z0-9_]+
+     */
+    CellName?: string | undefined;
+    /**
+     * A list of cell Amazon Resource Names (ARNs) contained within this cell, for use in nested cells. For example, Availability Zones within specific AWS Regions .
+     */
+    Cells?: string[] | undefined;
+    /**
+     * A collection of tags associated with a resource.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryReadinessCellAttribs = {
+    /**
+     * The ARN of the cell.
+     * @maxLength 256
+     */
+    CellArn: string;
+    /**
+     * The readiness scope for the cell, which can be the Amazon Resource Name (ARN) of a cell or the ARN of a recovery group. Although this is a list, it can currently have only one element.
+     */
+    ParentReadinessScopes: string[];
+};
+//# sourceMappingURL=aws-route53recoveryreadiness-cell.d.ts.map

package/out/exports/resources.generated/aws-route53recoveryreadiness-readinesscheck.d.ts

@@ -0,0 +1,37 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryReadinessReadinessCheck = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryReadiness::ReadinessCheck", Route53RecoveryReadinessReadinessCheckProps, Route53RecoveryReadinessReadinessCheckAttribs>;
+/**
+ * Creates a readiness check in Amazon Route 53 Application Recovery Controller. A readiness check continually monitors a resource set in your application, such as a set of Amazon Aurora instances, that Route 53 ARC is auditing recovery readiness for. The audits run once every minute on every resource that's associated with a readiness check.
+ *
+ * Every resource type has a set of rules associated with it that Route 53 ARC uses to audit resources for readiness. For more information, see [Readiness rules descriptions](https://docs.aws.amazon.com/r53recovery/latest/dg/recovery-readiness.rules-resources.html) in the Amazon Route 53 Application Recovery Controller Developer Guide.
+ *
+ * Route 53 ARC Readiness supports us-east-1 and us-west-2 AWS Regions only.
+ */
+export type Route53RecoveryReadinessReadinessCheckProps = {
+    /**
+     * The name of the readiness check to create.
+     * @minLength 1
+     * @maxLength 64
+     * @pattern [a-zA-Z0-9_]+
+     */
+    ReadinessCheckName?: string | undefined;
+    /**
+     * The name of the resource set to check.
+     * @minLength 1
+     * @maxLength 64
+     * @pattern [a-zA-Z0-9_]+
+     */
+    ResourceSetName?: string | undefined;
+    /**
+     * A collection of tags associated with a resource.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryReadinessReadinessCheckAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the readiness check.
+     * @maxLength 256
+     */
+    ReadinessCheckArn: string;
+};
+//# sourceMappingURL=aws-route53recoveryreadiness-readinesscheck.d.ts.map

package/out/exports/resources.generated/aws-route53recoveryreadiness-recoverygroup.d.ts

@@ -0,0 +1,34 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryReadinessRecoveryGroup = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryReadiness::RecoveryGroup", Route53RecoveryReadinessRecoveryGroupProps, Route53RecoveryReadinessRecoveryGroupAttribs>;
+/**
+ * Creates a recovery group in Amazon Route 53 Application Recovery Controller. A recovery group represents your application. It typically consists of two or more cells that are replicas of each other in terms of resources and functionality, so that you can fail over from one to the other, for example, from one Region to another. You create recovery groups so you can use readiness checks to audit resources in your application.
+ *
+ * For more information, see [Readiness checks, resource sets, and readiness scopes](https://docs.aws.amazon.com/r53recovery/latest/dg/recovery-readiness.recovery-groups.readiness-scope.html) in the Amazon Route 53 Application Recovery Controller Developer Guide.
+ *
+ * Route 53 ARC Readiness supports us-east-1 and us-west-2 AWS Regions only.
+ */
+export type Route53RecoveryReadinessRecoveryGroupProps = {
+    /**
+     * A list of the cell Amazon Resource Names (ARNs) in the recovery group.
+     */
+    Cells?: string[] | undefined;
+    /**
+     * The name of the recovery group to create.
+     * @minLength 1
+     * @maxLength 64
+     * @pattern [a-zA-Z0-9_]+
+     */
+    RecoveryGroupName?: string | undefined;
+    /**
+     * A collection of tags associated with a resource.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryReadinessRecoveryGroupAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the recovery group.
+     * @maxLength 256
+     */
+    RecoveryGroupArn: string;
+};
+//# sourceMappingURL=aws-route53recoveryreadiness-recoverygroup.d.ts.map

package/out/exports/resources.generated/aws-route53recoveryreadiness-resourceset.d.ts

@@ -0,0 +1,132 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53RecoveryReadinessResourceSet = ResourceDefinitionWithAttributes<"AWS::Route53RecoveryReadiness::ResourceSet", Route53RecoveryReadinessResourceSetProps, Route53RecoveryReadinessResourceSetAttribs>;
+/**
+ * Creates a resource set in Amazon Route 53 Application Recovery Controller. A resource set is a set of resources of one type, such as Network Load Balancers, that span multiple cells. You can associate a resource set with a readiness check to have Route 53 ARC continually monitor the resources in the set for failover readiness.
+ *
+ * You typically create a resource set and a readiness check for each supported type of AWS resource in your application.
+ *
+ * For more information, see [Readiness checks, resource sets, and readiness scopes](https://docs.aws.amazon.com/r53recovery/latest/dg/recovery-readiness.recovery-groups.readiness-scope.html) in the Amazon Route 53 Application Recovery Controller Developer Guide.
+ *
+ * Route 53 ARC Readiness supports us-east-1 and us-west-2 AWS Regions only.
+ */
+export type Route53RecoveryReadinessResourceSetProps = {
+    /**
+     * The name of the resource set to create.
+     */
+    ResourceSetName?: string | undefined;
+    /**
+     * The resource type of the resources in the resource set. Enter one of the following values for resource type:
+     *
+     * AWS::ApiGateway::Stage, AWS::ApiGatewayV2::Stage, AWS::AutoScaling::AutoScalingGroup, AWS::CloudWatch::Alarm, AWS::EC2::CustomerGateway, AWS::DynamoDB::Table, AWS::EC2::Volume, AWS::ElasticLoadBalancing::LoadBalancer, AWS::ElasticLoadBalancingV2::LoadBalancer, AWS::Lambda::Function, AWS::MSK::Cluster, AWS::RDS::DBCluster, AWS::Route53::HealthCheck, AWS::SQS::Queue, AWS::SNS::Topic, AWS::SNS::Subscription, AWS::EC2::VPC, AWS::EC2::VPNConnection, AWS::EC2::VPNGateway, AWS::Route53RecoveryReadiness::DNSTargetResource.
+     *
+     * Note that AWS::Route53RecoveryReadiness::DNSTargetResource is only used for this setting. It isn't an actual AWS CloudFormation resource type.
+     */
+    ResourceSetType: string;
+    /**
+     * A list of resource objects in the resource set.
+     */
+    Resources: Resource[];
+    /**
+     * A tag to associate with the parameters for a resource set.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53RecoveryReadinessResourceSetAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the resource set.
+     * @minLength 1
+     * @maxLength 256
+     */
+    ResourceSetArn: string;
+};
+/**
+ * A component for DNS/routing control readiness checks and architecture checks.
+ */
+export type DNSTargetResource = {
+    /**
+     * The domain name that acts as an ingress point to a portion of the customer application.
+     */
+    DomainName?: string | undefined;
+    /**
+     * The hosted zone Amazon Resource Name (ARN) that contains the DNS record with the provided name of the target resource.
+     */
+    HostedZoneArn?: string | undefined;
+    /**
+     * The Amazon Route 53 record set ID that uniquely identifies a DNS record, given a name and a type.
+     */
+    RecordSetId?: string | undefined;
+    /**
+     * The type of DNS record of the target resource.
+     */
+    RecordType?: string | undefined;
+    /**
+     * The target resource that the Route 53 record points to.
+     */
+    TargetResource?: TargetResource | undefined;
+};
+/**
+ * The Network Load Balancer resource that a DNS target resource points to.
+ */
+export type NLBResource = {
+    /**
+     * The Network Load Balancer resource Amazon Resource Name (ARN).
+     */
+    Arn?: string | undefined;
+};
+/**
+ * The Amazon Route 53 resource that a DNS target resource record points to.
+ */
+export type R53ResourceRecord = {
+    /**
+     * The DNS target domain name.
+     */
+    DomainName?: string | undefined;
+    /**
+     * The Amazon Route 53 Resource Record Set ID.
+     */
+    RecordSetId?: string | undefined;
+};
+/**
+ * The resource element of a resource set.
+ */
+export type Resource = {
+    /**
+     * The component identifier of the resource, generated when DNS target resource is used.
+     */
+    ComponentId?: string | undefined;
+    /**
+     * A component for DNS/routing control readiness checks. This is a required setting when `ResourceSet` `ResourceSetType` is set to `AWS::Route53RecoveryReadiness::DNSTargetResource` . Do not set it for any other `ResourceSetType` setting.
+     */
+    DnsTargetResource?: DNSTargetResource | undefined;
+    /**
+     * The recovery group Amazon Resource Name (ARN) or the cell ARN that the readiness checks for this resource set are scoped to.
+     */
+    ReadinessScopes?: string[] | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the AWS resource. This is a required setting for all `ResourceSet` `ResourceSetType` settings except `AWS::Route53RecoveryReadiness::DNSTargetResource` . Do not set this when `ResourceSetType` is set to `AWS::Route53RecoveryReadiness::DNSTargetResource` .
+     */
+    ResourceArn?: string | undefined;
+};
+/**
+ * The target resource that the Route 53 record points to.
+ */
+export type TargetResource = {
+    /**
+     * The Network Load Balancer resource that a DNS target resource points to.
+     */
+    NLBResource: NLBResource;
+    /**
+     * The Route 53 resource that a DNS target resource record points to.
+     */
+    R53Resource?: R53ResourceRecord | undefined;
+} | {
+    /**
+     * The Network Load Balancer resource that a DNS target resource points to.
+     */
+    NLBResource?: NLBResource | undefined;
+    /**
+     * The Route 53 resource that a DNS target resource record points to.
+     */
+    R53Resource: R53ResourceRecord;
+};
+//# sourceMappingURL=aws-route53recoveryreadiness-resourceset.d.ts.map

package/out/exports/resources.generated/aws-route53resolver-firewalldomainlist.d.ts

@@ -0,0 +1,84 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type Route53ResolverFirewallDomainList = ResourceDefinitionWithAttributes<"AWS::Route53Resolver::FirewallDomainList", Route53ResolverFirewallDomainListProps, Route53ResolverFirewallDomainListAttribs>;
+/**
+ * High-level information about a list of firewall domains for use in a [AWS::Route53Resolver::FirewallRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53resolver-firewallrulegroup-rule.html) . This is returned by [GetFirewallDomainList](https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_GetFirewallDomainList.html) .
+ *
+ * To retrieve the domains that are defined for this domain list, call [ListFirewallDomains](https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_ListFirewallDomains.html) .
+ */
+export type Route53ResolverFirewallDomainListProps = {
+    /**
+     * The fully qualified URL or URI of the file stored in Amazon Simple Storage Service (Amazon S3) that contains the list of domains to import.
+     *
+     * The file must be in an S3 bucket that's in the same Region as your DNS Firewall. The file must be a text file and must contain a single domain per line.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    DomainFileUrl?: string | undefined;
+    /**
+     * A list of the domain lists that you have defined.
+     */
+    Domains?: string[] | undefined;
+    /**
+     * The name of the domain list.
+     * @minLength 1
+     * @maxLength 64
+     * @pattern (?!^[0-9]+$)([a-zA-Z0-9\-_' ']+)
+     */
+    Name?: string | undefined;
+    /**
+     * A list of the tag keys and values that you want to associate with the domain list.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type Route53ResolverFirewallDomainListAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the firewall domain list.
+     * @minLength 1
+     * @maxLength 600
+     */
+    Arn: string;
+    /**
+     * The date and time that the domain list was created, in Unix time format and Coordinated Universal Time (UTC).
+     * @minLength 20
+     * @maxLength 40
+     */
+    CreationTime: string;
+    /**
+     * A unique string defined by you to identify the request. This allows you to retry failed requests without the risk of running the operation twice. This can be any unique string, for example, a timestamp.
+     * @minLength 1
+     * @maxLength 255
+     */
+    CreatorRequestId: string;
+    /**
+     * The number of domain names that are specified in the domain list.
+     * @min 0
+     */
+    DomainCount: number;
+    /**
+     * The ID of the domain list.
+     * @minLength 1
+     * @maxLength 64
+     */
+    Id: string;
+    /**
+     * The owner of the list, used only for lists that are not managed by you. For example, the managed domain list `AWSManagedDomainsMalwareDomainList` has the managed owner name `Route 53 Resolver DNS Firewall` .
+     * @minLength 1
+     * @maxLength 512
+     */
+    ManagedOwnerName: string;
+    /**
+     * The date and time that the domain list was last modified, in Unix time format and Coordinated Universal Time (UTC).
+     * @minLength 20
+     * @maxLength 40
+     */
+    ModificationTime: string;
+    /**
+     * The status of the domain list.
+     */
+    Status: "COMPLETE" | "DELETING" | "UPDATING" | "COMPLETE_IMPORT_FAILED" | "IMPORTING" | "INACTIVE_OWNER_ACCOUNT_CLOSED";
+    /**
+     * Additional information about the status of the list, if available.
+     */
+    StatusMessage: string;
+};
+//# sourceMappingURL=aws-route53resolver-firewalldomainlist.d.ts.map