@propulsionworks/cloudformation 0.0.1 → 0.1.0

package/out/exports/resources.generated/aws-ec2-networkinterface.d.ts

@@ -0,0 +1,171 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2NetworkInterface = ResourceDefinitionWithAttributes<"AWS::EC2::NetworkInterface", EC2NetworkInterfaceProps, EC2NetworkInterfaceAttribs>;
+/**
+ * Describes a network interface in an Amazon EC2 instance for AWS CloudFormation .
+ */
+export type EC2NetworkInterfaceProps = {
+    /**
+     * A connection tracking specification for the network interface.
+     */
+    ConnectionTrackingSpecification?: ConnectionTrackingSpecification | undefined;
+    /**
+     * A description for the network interface.
+     */
+    Description?: string | undefined;
+    /**
+     * If you’re modifying a network interface in a dual-stack or IPv6-only subnet, you have the option to assign a primary IPv6 IP address. A primary IPv6 address is an IPv6 GUA address associated with an ENI that you have enabled to use a primary IPv6 address. Use this option if the instance that this ENI will be attached to relies on its IPv6 address not changing. AWS will automatically assign an IPv6 address associated with the ENI attached to your instance to be the primary IPv6 address. Once you enable an IPv6 GUA address to be a primary IPv6, you cannot disable it. When you enable an IPv6 GUA address to be a primary IPv6, the first IPv6 GUA will be made the primary IPv6 address until the instance is terminated or the network interface is detached. If you have multiple IPv6 addresses associated with an ENI attached to your instance and you enable a primary IPv6 address, the first IPv6 GUA address associated with the ENI becomes the primary IPv6 address.
+     */
+    EnablePrimaryIpv6?: boolean | undefined;
+    /**
+     * The IDs of the security groups associated with this network interface.
+     */
+    GroupSet?: string[] | undefined;
+    /**
+     * The type of network interface. The default is `interface` . The supported values are `efa` and `trunk` .
+     */
+    InterfaceType?: string | undefined;
+    /**
+     * The number of IPv4 prefixes to be automatically assigned to the network interface.
+     *
+     * When creating a network interface, you can't specify a count of IPv4 prefixes if you've specified one of the following: specific IPv4 prefixes, specific private IPv4 addresses, or a count of private IPv4 addresses.
+     */
+    Ipv4PrefixCount?: number | undefined;
+    /**
+     * The IPv4 delegated prefixes that are assigned to the network interface.
+     *
+     * When creating a network interface, you can't specify IPv4 prefixes if you've specified one of the following: a count of IPv4 prefixes, specific private IPv4 addresses, or a count of private IPv4 addresses.
+     */
+    Ipv4Prefixes?: Ipv4PrefixSpecification[] | undefined;
+    /**
+     * The number of IPv6 addresses to assign to the network interface. Amazon EC2 automatically selects the IPv6 addresses from the subnet range. To specify specific IPv6 addresses, use the `Ipv6Addresses` property and don't specify this property.
+     *
+     * When creating a network interface, you can't specify a count of IPv6 addresses if you've specified one of the following: specific IPv6 addresses, specific IPv6 prefixes, or a count of IPv6 prefixes.
+     */
+    Ipv6AddressCount?: number | undefined;
+    /**
+     * The IPv6 addresses from the IPv6 CIDR block range of your subnet to assign to the network interface. If you're specifying a number of IPv6 addresses, use the `Ipv6AddressCount` property and don't specify this property.
+     *
+     * When creating a network interface, you can't specify IPv6 addresses if you've specified one of the following: a count of IPv6 addresses, specific IPv6 prefixes, or a count of IPv6 prefixes.
+     */
+    Ipv6Addresses?: InstanceIpv6Address[] | undefined;
+    /**
+     * The number of IPv6 prefixes to be automatically assigned to the network interface.
+     *
+     * When creating a network interface, you can't specify a count of IPv6 prefixes if you've specified one of the following: specific IPv6 prefixes, specific IPv6 addresses, or a count of IPv6 addresses.
+     */
+    Ipv6PrefixCount?: number | undefined;
+    /**
+     * The IPv6 delegated prefixes that are assigned to the network interface.
+     *
+     * When creating a network interface, you can't specify IPv6 prefixes if you've specified one of the following: a count of IPv6 prefixes, specific IPv6 addresses, or a count of IPv6 addresses.
+     */
+    Ipv6Prefixes?: Ipv6PrefixSpecification[] | undefined;
+    /**
+     * The private IPv4 address to assign to the network interface as the primary private IP address. If you want to specify multiple private IP addresses, use the `PrivateIpAddresses` property.
+     */
+    PrivateIpAddress?: string | undefined;
+    /**
+     * The private IPv4 addresses to assign to the network interface. You can specify a primary private IP address by setting the value of the `Primary` property to `true` in the `PrivateIpAddressSpecification` property. If you want EC2 to automatically assign private IP addresses, use the `SecondaryPrivateIpAddressCount` property and do not specify this property.
+     *
+     * When creating a network interface, you can't specify private IPv4 addresses if you've specified one of the following: a count of private IPv4 addresses, specific IPv4 prefixes, or a count of IPv4 prefixes.
+     */
+    PrivateIpAddresses?: PrivateIpAddressSpecification[] | undefined;
+    /**
+     * The number of secondary private IPv4 addresses to assign to a network interface. When you specify a number of secondary IPv4 addresses, Amazon EC2 selects these IP addresses within the subnet's IPv4 CIDR range. You can't specify this option and specify more than one private IP address using `privateIpAddresses` .
+     *
+     * When creating a Network Interface, you can't specify a count of private IPv4 addresses if you've specified one of the following: specific private IPv4 addresses, specific IPv4 prefixes, or a count of IPv4 prefixes.
+     */
+    SecondaryPrivateIpAddressCount?: number | undefined;
+    /**
+     * Enable or disable source/destination checks, which ensure that the instance is either the source or the destination of any traffic that it receives. If the value is `true` , source/destination checks are enabled; otherwise, they are disabled. The default value is `true` . You must disable source/destination checks if the instance runs services such as network address translation, routing, or firewalls.
+     */
+    SourceDestCheck?: boolean | undefined;
+    /**
+     * The ID of the subnet to associate with the network interface.
+     */
+    SubnetId: string;
+    /**
+     * The tags to apply to the network interface.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2NetworkInterfaceAttribs = {
+    /**
+     * The ID of the network interface.
+     */
+    Id: string;
+    /**
+     * The primary IPv6 address of the network interface.
+     */
+    PrimaryIpv6Address: string;
+    /**
+     * The primary private IP address of the network interface. For example, `10.0.0.192` .
+     */
+    PrimaryPrivateIpAddress: string;
+    /**
+     * The secondary private IP addresses of the network interface. For example, `["10.0.0.161", "10.0.0.162", "10.0.0.163"]` .
+     */
+    SecondaryPrivateIpAddresses: string[];
+    /**
+     * The ID of the VPC.
+     */
+    VpcId: string;
+};
+/**
+ * Configurable options for connection tracking on a network interface. For more information, see [Connection tracking timeouts](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html#connection-tracking-timeouts) in the *Amazon Elastic Compute Cloud User Guide* .
+ */
+export type ConnectionTrackingSpecification = {
+    /**
+     * Timeout (in seconds) for idle TCP connections in an established state. Min: 60 seconds. Max: 432000 seconds (5 days). Default: 432000 seconds. Recommended: Less than 432000 seconds.
+     */
+    TcpEstablishedTimeout?: number | undefined;
+    /**
+     * Timeout (in seconds) for idle UDP flows classified as streams which have seen more than one request-response transaction. Min: 60 seconds. Max: 180 seconds (3 minutes). Default: 180 seconds.
+     */
+    UdpStreamTimeout?: number | undefined;
+    /**
+     * Timeout (in seconds) for idle UDP flows that have seen traffic only in a single direction or a single request-response transaction. Min: 30 seconds. Max: 60 seconds. Default: 30 seconds.
+     */
+    UdpTimeout?: number | undefined;
+};
+/**
+ * Describes the IPv6 addresses to associate with the network interface.
+ */
+export type InstanceIpv6Address = {
+    /**
+     * An IPv6 address to associate with the network interface.
+     */
+    Ipv6Address: string;
+};
+/**
+ * Describes an IPv4 prefix.
+ */
+export type Ipv4PrefixSpecification = {
+    /**
+     * The IPv4 prefix. For information, see [Assigning prefixes to network interfaces](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html) in the *Amazon EC2 User Guide* .
+     */
+    Ipv4Prefix: string;
+};
+/**
+ * Describes the IPv6 prefix.
+ */
+export type Ipv6PrefixSpecification = {
+    /**
+     * The IPv6 prefix. For information, see [Assigning prefixes to Amazon EC2 network interfaces](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html) in the *Amazon Elastic Compute Cloud User Guide* .
+     */
+    Ipv6Prefix: string;
+};
+/**
+ * Describes a secondary private IPv4 address for a network interface.
+ */
+export type PrivateIpAddressSpecification = {
+    /**
+     * Sets the private IP address as the primary private address. You can set only one primary private IP address. If you don't specify a primary private IP address, Amazon EC2 automatically assigns a primary private IP address.
+     */
+    Primary: boolean;
+    /**
+     * The private IP address of the network interface.
+     */
+    PrivateIpAddress: string;
+};
+//# sourceMappingURL=aws-ec2-networkinterface.d.ts.map

package/out/exports/resources.generated/aws-ec2-networkinterfaceattachment.d.ts

@@ -0,0 +1,52 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type EC2NetworkInterfaceAttachment = ResourceDefinitionWithAttributes<"AWS::EC2::NetworkInterfaceAttachment", EC2NetworkInterfaceAttachmentProps, EC2NetworkInterfaceAttachmentAttribs>;
+/**
+ * Attaches an elastic network interface (ENI) to an Amazon EC2 instance. You can use this resource type to attach additional network interfaces to an instance without interruption.
+ */
+export type EC2NetworkInterfaceAttachmentProps = {
+    /**
+     * Whether to delete the network interface when the instance terminates. By default, this value is set to `true` .
+     * @default true
+     */
+    DeleteOnTermination?: boolean | undefined;
+    /**
+     * The network interface's position in the attachment order. For example, the first attached network interface has a `DeviceIndex` of 0.
+     */
+    DeviceIndex: string;
+    /**
+     * Configures ENA Express for the network interface that this action attaches to the instance.
+     */
+    EnaSrdSpecification?: EnaSrdSpecification | undefined;
+    /**
+     * The ID of the instance to which you will attach the ENI.
+     */
+    InstanceId: string;
+    /**
+     * The ID of the ENI that you want to attach.
+     */
+    NetworkInterfaceId: string;
+};
+export type EC2NetworkInterfaceAttachmentAttribs = {
+    /**
+     * The ID of the network interface attachment.
+     */
+    AttachmentId: string;
+};
+/**
+ * ENA Express uses AWS Scalable Reliable Datagram (SRD) technology to increase the maximum bandwidth used per stream and minimize tail latency of network traffic between EC2 instances. With ENA Express, you can communicate between two EC2 instances in the same subnet within the same account, or in different accounts. Both sending and receiving instances must have ENA Express enabled.
+ *
+ * To improve the reliability of network packet delivery, ENA Express reorders network packets on the receiving end by default. However, some UDP-based applications are designed to handle network packets that are out of order to reduce the overhead for packet delivery at the network layer. When ENA Express is enabled, you can specify whether UDP network traffic uses it.
+ */
+export type EnaSrdSpecification = {
+    /**
+     * Indicates whether ENA Express is enabled for the network interface.
+     */
+    EnaSrdEnabled?: boolean | undefined;
+    /**
+     * Configures ENA Express for UDP network traffic.
+     */
+    EnaSrdUdpSpecification?: {
+        EnaSrdUdpEnabled?: boolean | undefined;
+    } | undefined;
+};
+//# sourceMappingURL=aws-ec2-networkinterfaceattachment.d.ts.map

package/out/exports/resources.generated/aws-ec2-networkinterfacepermission.d.ts

@@ -0,0 +1,23 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type EC2NetworkInterfacePermission = ResourceDefinitionWithAttributes<"AWS::EC2::NetworkInterfacePermission", EC2NetworkInterfacePermissionProps, EC2NetworkInterfacePermissionAttribs>;
+/**
+ * Specifies a permission for an Amazon EC2 network interface. For example, you can grant an AWS authorized partner account permission to attach the specified network interface to an instance in their account.
+ */
+export type EC2NetworkInterfacePermissionProps = {
+    /**
+     * The AWS account ID.
+     */
+    AwsAccountId: string;
+    /**
+     * The ID of the network interface.
+     */
+    NetworkInterfaceId: string;
+    /**
+     * The type of permission to grant: `INSTANCE-ATTACH` or `EIP-ASSOCIATE` .
+     */
+    Permission: string;
+};
+export type EC2NetworkInterfacePermissionAttribs = {
+    Id: string;
+};
+//# sourceMappingURL=aws-ec2-networkinterfacepermission.d.ts.map

package/out/exports/resources.generated/aws-ec2-networkperformancemetricsubscription.d.ts

@@ -0,0 +1,24 @@
+import type { ResourceDefinition } from "../main.ts";
+export type EC2NetworkPerformanceMetricSubscription = ResourceDefinition<"AWS::EC2::NetworkPerformanceMetricSubscription", EC2NetworkPerformanceMetricSubscriptionProps>;
+/**
+ * Describes Infrastructure Performance subscriptions.
+ */
+export type EC2NetworkPerformanceMetricSubscriptionProps = {
+    /**
+     * The Region or Availability Zone that's the target for the subscription. For example, `eu-west-1` .
+     */
+    Destination: string;
+    /**
+     * The metric used for the subscription.
+     */
+    Metric: string;
+    /**
+     * The Region or Availability Zone that's the source for the subscription. For example, `us-east-1` .
+     */
+    Source: string;
+    /**
+     * The statistic used for the subscription.
+     */
+    Statistic: string;
+};
+//# sourceMappingURL=aws-ec2-networkperformancemetricsubscription.d.ts.map

package/out/exports/resources.generated/aws-ec2-placementgroup.d.ts

@@ -0,0 +1,37 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2PlacementGroup = ResourceDefinitionWithAttributes<"AWS::EC2::PlacementGroup", EC2PlacementGroupProps, EC2PlacementGroupAttribs>;
+/**
+ * Specifies a placement group in which to launch instances. The strategy of the placement group determines how the instances are organized within the group.
+ *
+ * A `cluster` placement group is a logical grouping of instances within a single Availability Zone that benefit from low network latency, high network throughput. A `spread` placement group places instances on distinct hardware. A `partition` placement group places groups of instances in different partitions, where instances in one partition do not share the same hardware with instances in another partition.
+ *
+ * For more information, see [Placement Groups](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html) in the *Amazon EC2 User Guide* .
+ */
+export type EC2PlacementGroupProps = {
+    /**
+     * The number of partitions. Valid only when *Strategy* is set to `partition` .
+     */
+    PartitionCount?: number | undefined;
+    /**
+     * Determines how placement groups spread instances.
+     *
+     * - Host – You can use `host` only with Outpost placement groups.
+     * - Rack – No usage restrictions.
+     */
+    SpreadLevel?: string | undefined;
+    /**
+     * The placement strategy.
+     */
+    Strategy?: string | undefined;
+    /**
+     * The tags to apply to the new placement group.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2PlacementGroupAttribs = {
+    /**
+     * The name of the placement group.
+     */
+    GroupName: string;
+};
+//# sourceMappingURL=aws-ec2-placementgroup.d.ts.map

package/out/exports/resources.generated/aws-ec2-prefixlist.d.ts

@@ -0,0 +1,74 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2PrefixList = ResourceDefinitionWithAttributes<"AWS::EC2::PrefixList", EC2PrefixListProps, EC2PrefixListAttribs>;
+/**
+ * Specifies a managed prefix list. You can add one or more entries to the prefix list. Each entry consists of a CIDR block and an optional description.
+ */
+export type EC2PrefixListProps = {
+    /**
+     * The IP address type.
+     *
+     * Valid Values: `IPv4` | `IPv6`
+     */
+    AddressFamily: "IPv4" | "IPv6";
+    /**
+     * The entries for the prefix list.
+     */
+    Entries?: Entry[] | undefined;
+    /**
+     * The maximum number of entries for the prefix list. You can't modify the entries and the size of a prefix list at the same time.
+     *
+     * This property is required when you create a prefix list.
+     * @min 1
+     */
+    MaxEntries?: number | undefined;
+    /**
+     * A name for the prefix list.
+     *
+     * Constraints: Up to 255 characters in length. The name cannot start with `com.amazonaws` .
+     * @minLength 1
+     * @maxLength 255
+     */
+    PrefixListName: string;
+    /**
+     * The tags for the prefix list.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2PrefixListAttribs = {
+    /**
+     * The ARN of the prefix list. For example, `arn:aws:ec2:us-east-1:123456789012:prefix-list/pl-0123123123123abcd` .
+     */
+    Arn: string;
+    /**
+     * The ID of the owner of the prefix list. For example, `123456789012` .
+     */
+    OwnerId: string;
+    /**
+     * The ID of the prefix list. For example, `pl-0123123123123abcd` .
+     */
+    PrefixListId: string;
+    /**
+     * The version of the prefix list. For example, `1` .
+     */
+    Version: number;
+};
+/**
+ * An entry for a prefix list.
+ */
+export type Entry = {
+    /**
+     * The CIDR block.
+     * @minLength 1
+     * @maxLength 46
+     */
+    Cidr: string;
+    /**
+     * A description for the entry.
+     *
+     * Constraints: Up to 255 characters in length.
+     * @minLength 0
+     * @maxLength 255
+     */
+    Description?: string | undefined;
+};
+//# sourceMappingURL=aws-ec2-prefixlist.d.ts.map

package/out/exports/resources.generated/aws-ec2-route.d.ts

@@ -0,0 +1,80 @@
+import type { ResourceDefinitionWithAttributes } from "../main.ts";
+export type EC2Route = ResourceDefinitionWithAttributes<"AWS::EC2::Route", EC2RouteProps, EC2RouteAttribs>;
+/**
+ * Specifies a route in a route table. For more information, see [Routes](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html#route-table-routes) in the *Amazon VPC User Guide* .
+ *
+ * You must specify either a destination CIDR block or prefix list ID. You must also specify exactly one of the resources as the target.
+ *
+ * If you create a route that references a transit gateway in the same template where you create the transit gateway, you must declare a dependency on the transit gateway attachment. The route table cannot use the transit gateway until it has successfully attached to the VPC. Add a [DependsOn Attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html) in the `AWS::EC2::Route` resource to explicitly declare a dependency on the `AWS::EC2::TransitGatewayAttachment` resource.
+ */
+export type EC2RouteProps = {
+    /**
+     * The ID of the carrier gateway.
+     *
+     * You can only use this option when the VPC contains a subnet which is associated with a Wavelength Zone.
+     */
+    CarrierGatewayId?: string | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the core network.
+     */
+    CoreNetworkArn?: string | undefined;
+    /**
+     * The IPv4 CIDR address block used for the destination match. Routing decisions are based on the most specific match. We modify the specified CIDR block to its canonical form; for example, if you specify `100.68.0.18/18` , we modify it to `100.68.0.0/18` .
+     */
+    DestinationCidrBlock?: string | undefined;
+    /**
+     * The IPv6 CIDR block used for the destination match. Routing decisions are based on the most specific match.
+     */
+    DestinationIpv6CidrBlock?: string | undefined;
+    /**
+     * The ID of a prefix list used for the destination match.
+     */
+    DestinationPrefixListId?: string | undefined;
+    /**
+     * [IPv6 traffic only] The ID of an egress-only internet gateway.
+     */
+    EgressOnlyInternetGatewayId?: string | undefined;
+    /**
+     * The ID of an internet gateway or virtual private gateway attached to your VPC.
+     */
+    GatewayId?: string | undefined;
+    /**
+     * The ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached.
+     */
+    InstanceId?: string | undefined;
+    /**
+     * The ID of the local gateway.
+     */
+    LocalGatewayId?: string | undefined;
+    /**
+     * [IPv4 traffic only] The ID of a NAT gateway.
+     */
+    NatGatewayId?: string | undefined;
+    /**
+     * The ID of a network interface.
+     */
+    NetworkInterfaceId?: string | undefined;
+    /**
+     * The ID of the route table for the route.
+     */
+    RouteTableId: string;
+    /**
+     * The ID of a transit gateway.
+     */
+    TransitGatewayId?: string | undefined;
+    /**
+     * The ID of a VPC endpoint. Supported for Gateway Load Balancer endpoints only.
+     */
+    VpcEndpointId?: string | undefined;
+    /**
+     * The ID of a VPC peering connection.
+     */
+    VpcPeeringConnectionId?: string | undefined;
+};
+export type EC2RouteAttribs = {
+    /**
+     * The IPv4 CIDR block.
+     */
+    CidrBlock: string;
+};
+//# sourceMappingURL=aws-ec2-route.d.ts.map

package/out/exports/resources.generated/aws-ec2-routeserver.d.ts

@@ -0,0 +1,50 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2RouteServer = ResourceDefinitionWithAttributes<"AWS::EC2::RouteServer", EC2RouteServerProps, EC2RouteServerAttribs>;
+/**
+ * Specifies a route server to manage dynamic routing in a VPC.
+ *
+ * Amazon VPC Route Server simplifies routing for traffic between workloads that are deployed within a VPC and its internet gateways. With this feature, VPC Route Server dynamically updates VPC and internet gateway route tables with your preferred routes to achieve routing fault tolerance for those workloads. This enables you to automatically reroute traffic within a VPC, which increases the manageability of VPC routing and interoperability with third-party workloads.
+ *
+ * For more information see [Dynamic routing in your VPC with VPC Route Server](https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html) in the *Amazon VPC User Guide* .
+ */
+export type EC2RouteServerProps = {
+    /**
+     * The Border Gateway Protocol (BGP) Autonomous System Number (ASN) for the appliance. Valid values are from 1 to 4294967295. We recommend using a private ASN in the 64512–65534 (16-bit ASN) or 4200000000–4294967294 (32-bit ASN) range.
+     * @min 1
+     * @max 4294967294
+     * @format int64
+     */
+    AmazonSideAsn: number;
+    /**
+     * Indicates whether routes should be persisted after all BGP sessions are terminated.
+     */
+    PersistRoutes?: "enable" | "disable" | undefined;
+    /**
+     * The number of minutes a route server will wait after BGP is re-established to unpersist the routes in the FIB and RIB. Value must be in the range of 1-5. The default value is 1. Only valid if `persistRoutesState` is 'enabled'.
+     *
+     * If you set the duration to 1 minute, then when your network appliance re-establishes BGP with route server, it has 1 minute to relearn it's adjacent network and advertise those routes to route server before route server resumes normal functionality. In most cases, 1 minute is probably sufficient. If, however, you have concerns that your BGP network may not be capable of fully re-establishing and re-learning everything in 1 minute, you can increase the duration up to 5 minutes.
+     * @min 0
+     * @max 5
+     * @format int64
+     */
+    PersistRoutesDuration?: number | undefined;
+    /**
+     * Indicates whether SNS notifications are enabled for the route server. Enabling SNS notifications persists BGP status changes to an SNS topic provisioned by AWS .
+     */
+    SnsNotificationsEnabled?: boolean | undefined;
+    /**
+     * Any tags assigned to the route server.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2RouteServerAttribs = {
+    /**
+     * The ARN of the route server.
+     */
+    Arn: string;
+    /**
+     * The ID of the route server.
+     */
+    Id: string;
+};
+//# sourceMappingURL=aws-ec2-routeserver.d.ts.map

package/out/exports/resources.generated/aws-ec2-routeserverassociation.d.ts

@@ -0,0 +1,18 @@
+import type { ResourceDefinition } from "../main.ts";
+export type EC2RouteServerAssociation = ResourceDefinition<"AWS::EC2::RouteServerAssociation", EC2RouteServerAssociationProps>;
+/**
+ * Specifies the association between a route server and a VPC.
+ *
+ * A route server association is the connection established between a route server and a VPC.
+ */
+export type EC2RouteServerAssociationProps = {
+    /**
+     * The ID of the associated route server.
+     */
+    RouteServerId: string;
+    /**
+     * The ID of the associated VPC.
+     */
+    VpcId: string;
+};
+//# sourceMappingURL=aws-ec2-routeserverassociation.d.ts.map

package/out/exports/resources.generated/aws-ec2-routeserverendpoint.d.ts

@@ -0,0 +1,46 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2RouteServerEndpoint = ResourceDefinitionWithAttributes<"AWS::EC2::RouteServerEndpoint", EC2RouteServerEndpointProps, EC2RouteServerEndpointAttribs>;
+/**
+ * Creates a new endpoint for a route server in a specified subnet.
+ *
+ * A route server endpoint is an AWS -managed component inside a subnet that facilitates [BGP (Border Gateway Protocol)](https://docs.aws.amazon.com/https://en.wikipedia.org/wiki/Border_Gateway_Protocol) connections between your route server and your BGP peers.
+ *
+ * For more information see [Dynamic routing in your VPC with VPC Route Server](https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html) in the *Amazon VPC User Guide* .
+ */
+export type EC2RouteServerEndpointProps = {
+    /**
+     * The ID of the route server associated with this endpoint.
+     */
+    RouteServerId: string;
+    /**
+     * The ID of the subnet to place the route server endpoint into.
+     */
+    SubnetId: string;
+    /**
+     * Any tags assigned to the route server endpoint.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2RouteServerEndpointAttribs = {
+    /**
+     * The ARN for the endpoint.
+     */
+    Arn: string;
+    /**
+     * The IP address of the Elastic network interface for the endpoint.
+     */
+    EniAddress: string;
+    /**
+     * The ID of the Elastic network interface for the endpoint.
+     */
+    EniId: string;
+    /**
+     * The unique identifier of the route server endpoint.
+     */
+    Id: string;
+    /**
+     * The ID of the VPC containing the endpoint.
+     */
+    VpcId: string;
+};
+//# sourceMappingURL=aws-ec2-routeserverendpoint.d.ts.map

package/out/exports/resources.generated/aws-ec2-routeserverpeer.d.ts

@@ -0,0 +1,79 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type EC2RouteServerPeer = ResourceDefinitionWithAttributes<"AWS::EC2::RouteServerPeer", EC2RouteServerPeerProps, EC2RouteServerPeerAttribs>;
+/**
+ * Specifies a BGP peer configuration for a route server endpoint.
+ *
+ * A route server peer is a session between a route server endpoint and the device deployed in AWS (such as a firewall appliance or other network security function running on an EC2 instance).
+ */
+export type EC2RouteServerPeerProps = {
+    /**
+     * The BGP configuration options for this peer, including ASN (Autonomous System Number) and BFD (Bidrectional Forwarding Detection) settings.
+     */
+    BgpOptions: BgpOptions;
+    /**
+     * The IPv4 address of the peer device.
+     */
+    PeerAddress: string;
+    /**
+     * The ID of the route server endpoint associated with this peer.
+     */
+    RouteServerEndpointId: string;
+    /**
+     * Any tags assigned to the route server peer.
+     */
+    Tags?: Tag[] | undefined;
+};
+export type EC2RouteServerPeerAttribs = {
+    /**
+     * The ARN of the route server peer.
+     */
+    Arn: string;
+    /**
+     * The IP address of the Elastic network interface for the route server endpoint.
+     */
+    EndpointEniAddress: string;
+    /**
+     * The ID of the Elastic network interface for the route server endpoint.
+     */
+    EndpointEniId: string;
+    /**
+     * The ID of the route server peer.
+     */
+    Id: string;
+    /**
+     * The ID of the route server associated with this peer.
+     */
+    RouteServerId: string;
+    /**
+     * The ID of the subnet containing the route server peer.
+     */
+    SubnetId: string;
+    /**
+     * The ID of the VPC containing the route server peer.
+     */
+    VpcId: string;
+};
+/**
+ * The BGP configuration options for this peer, including ASN (Autonomous System Number) and BFD (Bidrectional Forwarding Detection) settings.
+ */
+export type BgpOptions = {
+    /**
+     * The Border Gateway Protocol (BGP) Autonomous System Number (ASN) for the appliance. Valid values are from 1 to 4294967295. We recommend using a private ASN in the 64512–65534 (16-bit ASN) or 4200000000–4294967294 (32-bit ASN) range.
+     * @min 1
+     * @max 4294967294
+     * @format int64
+     */
+    PeerAsn?: number | undefined;
+    /**
+     * The liveness detection protocol used for the BGP peer.
+     *
+     * The requested liveness detection protocol for the BGP peer.
+     *
+     * - `bgp-keepalive` : The standard BGP keep alive mechanism ( [RFC4271](https://docs.aws.amazon.com/https://www.rfc-editor.org/rfc/rfc4271#page-21) ) that is stable but may take longer to fail-over in cases of network impact or router failure.
+     * - `bfd` : An additional Bidirectional Forwarding Detection (BFD) protocol ( [RFC5880](https://docs.aws.amazon.com/https://www.rfc-editor.org/rfc/rfc5880) ) that enables fast failover by using more sensitive liveness detection.
+     *
+     * Defaults to `bgp-keepalive` .
+     */
+    PeerLivenessDetection?: "bfd" | "bgp-keepalive" | undefined;
+};
+//# sourceMappingURL=aws-ec2-routeserverpeer.d.ts.map