'''
# Amazon EC2 Construct Library

The `aws-cdk-lib/aws-ec2` package contains primitives for setting up networking and
instances.

```python
import aws_cdk.aws_ec2 as ec2
```

## VPC

Most projects need a Virtual Private Cloud to provide security by means of
network partitioning. This is achieved by creating an instance of
`Vpc`:

```python
vpc = ec2.Vpc(self, "VPC")
```

All default constructs require EC2 instances to be launched inside a VPC, so
you should generally start by defining a VPC whenever you need to launch
instances for your project.

### Subnet Types

A VPC consists of one or more subnets that instances can be placed into. CDK
distinguishes three different subnet types:

* **Public (`SubnetType.PUBLIC`)** - public subnets connect directly to the Internet using an
  Internet Gateway. If you want your instances to have a public IP address
  and be directly reachable from the Internet, you must place them in a
  public subnet.
* **Private with Internet Access (`SubnetType.PRIVATE_WITH_EGRESS`)** - instances in private subnets are not directly routable from the
  Internet, and you must provide a way to connect out to the Internet.
  By default, a NAT gateway is created in every public subnet for maximum availability. Be
  aware that you will be charged for NAT gateways.
  Alternatively you can set `natGateways:0` and provide your own egress configuration (i.e through Transit Gateway)
* **Isolated (`SubnetType.PRIVATE_ISOLATED`)** - isolated subnets do not route from or to the Internet, and
  as such do not require NAT gateways. They can only connect to or be
  connected to from other instances in the same VPC. A default VPC configuration
  will not include isolated subnets,

A default VPC configuration will create public and **private** subnets. However, if
`natGateways:0` **and** `subnetConfiguration` is undefined, default VPC configuration
will create public and **isolated** subnets. See [*Advanced Subnet Configuration*](#advanced-subnet-configuration)
below for information on how to change the default subnet configuration.

Constructs using the VPC will "launch instances" (or more accurately, create
Elastic Network Interfaces) into one or more of the subnets. They all accept
a property called `subnetSelection` (sometimes called `vpcSubnets`) to allow
you to select in what subnet to place the ENIs, usually defaulting to
*private* subnets if the property is omitted.

If you would like to save on the cost of NAT gateways, you can use
*isolated* subnets instead of *private* subnets (as described in Advanced
*Subnet Configuration*). If you need private instances to have
internet connectivity, another option is to reduce the number of NAT gateways
created by setting the `natGateways` property to a lower value (the default
is one NAT gateway per availability zone). Be aware that this may have
availability implications for your application.

[Read more about
subnets](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Subnets.html).

### Control over availability zones

By default, a VPC will spread over at most 3 Availability Zones available to
it. To change the number of Availability Zones that the VPC will spread over,
specify the `maxAzs` property when defining it.

The number of Availability Zones that are available depends on the *region*
and *account* of the Stack containing the VPC. If the [region and account are
specified](https://docs.aws.amazon.com/cdk/latest/guide/environments.html) on
the Stack, the CLI will [look up the existing Availability
Zones](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#using-regions-availability-zones-describe)
and get an accurate count. The result of this operation will be written to a file
called `cdk.context.json`. You must commit this file to source control so
that the lookup values are available in non-privileged environments such
as CI build steps, and to ensure your template builds are repeatable.

If region and account are not specified, the stack
could be deployed anywhere and it will have to make a safe choice, limiting
itself to 2 Availability Zones.

Therefore, to get the VPC to spread over 3 or more availability zones, you
must specify the environment where the stack will be deployed.

You can gain full control over the availability zones selection strategy by overriding the Stack's [`get availabilityZones()`](https://github.com/aws/aws-cdk/blob/main/packages/@aws-cdk/core/lib/stack.ts) method:

```text
// This example is only available in TypeScript

class MyStack extends Stack {

  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // ...
  }

  get availabilityZones(): string[] {
    return ['us-west-2a', 'us-west-2b'];
  }

}
```

Note that overriding the `get availabilityZones()` method will override the default behavior for all constructs defined within the Stack.

### Choosing subnets for resources

When creating resources that create Elastic Network Interfaces (such as
databases or instances), there is an option to choose which subnets to place
them in. For example, a VPC endpoint by default is placed into a subnet in
every availability zone, but you can override which subnets to use. The property
is typically called one of `subnets`, `vpcSubnets` or `subnetSelection`.

The example below will place the endpoint into two AZs (`us-east-1a` and `us-east-1c`),
in Isolated subnets:

```python
# vpc: ec2.Vpc


ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
    vpc=vpc,
    service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
    subnets=ec2.SubnetSelection(
        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
        availability_zones=["us-east-1a", "us-east-1c"]
    )
)
```

You can also specify specific subnet objects for granular control:

```python
# vpc: ec2.Vpc
# subnet1: ec2.Subnet
# subnet2: ec2.Subnet


ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
    vpc=vpc,
    service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
    subnets=ec2.SubnetSelection(
        subnets=[subnet1, subnet2]
    )
)
```

Which subnets are selected is evaluated as follows:

* `subnets`: if specific subnet objects are supplied, these are selected, and no other
  logic is used.
* `subnetType`/`subnetGroupName`: otherwise, a set of subnets is selected by
  supplying either type or name:

  * `subnetType` will select all subnets of the given type.
  * `subnetGroupName` should be used to distinguish between multiple groups of subnets of
    the same type (for example, you may want to separate your application instances and your
    RDS instances into two distinct groups of Isolated subnets).
  * If neither are given, the first available subnet group of a given type that
    exists in the VPC will be used, in this order: Private, then Isolated, then Public.
    In short: by default ENIs will preferentially be placed in subnets not connected to
    the Internet.
* `availabilityZones`/`onePerAz`: finally, some availability-zone based filtering may be done.
  This filtering by availability zones will only be possible if the VPC has been created or
  looked up in a non-environment agnostic stack (so account and region have been set and
  availability zones have been looked up).

  * `availabilityZones`: only the specific subnets from the selected subnet groups that are
    in the given availability zones will be returned.
  * `onePerAz`: per availability zone, a maximum of one subnet will be returned (Useful for resource
    types that do not allow creating two ENIs in the same availability zone).
* `subnetFilters`: additional filtering on subnets using any number of user-provided filters which
  extend `SubnetFilter`.  The following methods on the `SubnetFilter` class can be used to create
  a filter:

  * `byIds`: chooses subnets from a list of ids
  * `availabilityZones`: chooses subnets in the provided list of availability zones
  * `onePerAz`: chooses at most one subnet per availability zone
  * `containsIpAddresses`: chooses a subnet which contains *any* of the listed ip addresses
  * `byCidrMask`: chooses subnets that have the provided CIDR netmask
  * `byCidrRanges`: chooses subnets which are inside any of the specified CIDR ranges

### Using NAT instances

By default, the `Vpc` construct will create NAT *gateways* for you, which
are managed by AWS. If you would prefer to use your own managed NAT
*instances* instead, specify a different value for the `natGatewayProvider`
property, as follows:

```python
# Configure the `natGatewayProvider` when defining a Vpc
nat_gateway_provider = ec2.NatProvider.instance(
    instance_type=ec2.InstanceType("t3.small")
)

vpc = ec2.Vpc(self, "MyVpc",
    nat_gateway_provider=nat_gateway_provider,

    # The 'natGateways' parameter now controls the number of NAT instances
    nat_gateways=2
)
```

The construct will automatically search for the most recent NAT gateway AMI.
If you prefer to use a custom AMI, use `machineImage: MachineImage.genericLinux({ ... })` and configure the right AMI ID for the
regions you want to deploy to.

By default, the NAT instances will route all traffic. To control what traffic
gets routed, pass a custom value for `defaultAllowedTraffic` and access the
`NatInstanceProvider.connections` member after having passed the NAT provider to
the VPC:

```python
# instance_type: ec2.InstanceType


provider = ec2.NatProvider.instance(
    instance_type=instance_type,
    default_allowed_traffic=ec2.NatTrafficDirection.OUTBOUND_ONLY
)
ec2.Vpc(self, "TheVPC",
    nat_gateway_provider=provider
)
provider.connections.allow_from(ec2.Peer.ipv4("1.2.3.4/8"), ec2.Port.tcp(80))
```

### Ip Address Management

The VPC spans a supernet IP range, which contains the non-overlapping IPs of its contained subnets. Possible sources for this IP range are:

* You specify an IP range directly by specifying a CIDR
* You allocate an IP range of a given size automatically from AWS IPAM

By default the Vpc will allocate the `10.0.0.0/16` address range which will be exhaustively spread across all subnets in the subnet configuration. This behavior can be changed by passing an object that implements `IIpAddresses` to the `ipAddress` property of a Vpc. See the subsequent sections for the options.

Be aware that if you don't explicitly reserve subnet groups in `subnetConfiguration`, the address space will be fully allocated! If you predict you may need to add more subnet groups later, add them early on and set `reserved: true` (see the "Advanced Subnet Configuration" section for more information).

#### Specifying a CIDR directly

Use `IpAddresses.cidr` to define a Cidr range for your Vpc directly in code:

```python
from aws_cdk.aws_ec2 import IpAddresses


ec2.Vpc(self, "TheVPC",
    ip_addresses=IpAddresses.cidr("10.0.1.0/20")
)
```

Space will be allocated to subnets in the following order:

* First, spaces is allocated for all subnets groups that explicitly have a `cidrMask` set as part of their configuration (including reserved subnets).
* Afterwards, any remaining space is divided evenly between the rest of the subnets (if any).

The argument to `IpAddresses.cidr` may not be a token, and concrete Cidr values are generated in the synthesized CloudFormation template.

#### Allocating an IP range from AWS IPAM

Amazon VPC IP Address Manager (IPAM) manages a large IP space, from which chunks can be allocated for use in the Vpc. For information on Amazon VPC IP Address Manager please see the [official documentation](https://docs.aws.amazon.com/vpc/latest/ipam/what-it-is-ipam.html). An example of allocating from AWS IPAM looks like this:

```python
from aws_cdk.aws_ec2 import IpAddresses

# pool: ec2.CfnIPAMPool


ec2.Vpc(self, "TheVPC",
    ip_addresses=IpAddresses.aws_ipam_allocation(
        ipv4_ipam_pool_id=pool.ref,
        ipv4_netmask_length=18,
        default_subnet_ipv4_netmask_length=24
    )
)
```

`IpAddresses.awsIpamAllocation` requires the following:

* `ipv4IpamPoolId`, the id of an IPAM Pool from which the VPC range should be allocated.
* `ipv4NetmaskLength`, the size of the IP range that will be requested from the Pool at deploy time.
* `defaultSubnetIpv4NetmaskLength`, the size of subnets in groups that don't have `cidrMask` set.

With this method of IP address management, no attempt is made to guess at subnet group sizes or to exhaustively allocate the IP range. All subnet groups must have an explicit `cidrMask` set as part of their subnet configuration, or `defaultSubnetIpv4NetmaskLength` must be set for a default size. If not, synthesis will fail and you must provide one or the other.

### Dual Stack configuration

To allocate both IPv4 and IPv6 addresses in your VPC, you can configure your VPC to have a dual stack protocol.

```python
ec2.Vpc(self, "DualStackVpc",
    ip_protocol=ec2.IpProtocol.DUAL_STACK
)
```

By default, a dual stack VPC will create an Amazon provided IPv6 /56 CIDR block associated to the VPC. It will then assign /64 portions of the block to each subnet. For each subnet, auto-assigning an IPv6 address will be enabled, and auto-asigning a public IPv4 address will be disabled. An egress only internet gateway will be created for `PRIVATE_WITH_EGRESS` subnets, and IPv6 routes will be added for IGWs and EIGWs.

Disabling the auto-assigning of a public IPv4 address by default can avoid the cost of public IPv4 addresses starting 2/1/2024. For use cases that need an IPv4 address, the `mapPublicIpOnLaunch` property in `subnetConfiguration` can be set to auto-assign the IPv4 address. Note that private IPv4 address allocation will not be changed.

See [Advanced Subnet Configuration](#advanced-subnet-configuration) for all IPv6 specific properties.

### Reserving availability zones

There are situations where the IP space for availability zones will
need to be reserved. This is useful in situations where availability
zones would need to be added after the vpc is originally deployed,
without causing IP renumbering for availability zones subnets. The IP
space for reserving `n` availability zones can be done by setting the
`reservedAzs` to `n` in vpc props, as shown below:

```python
vpc = ec2.Vpc(self, "TheVPC",
    cidr="10.0.0.0/21",
    max_azs=3,
    reserved_azs=1
)
```

In the example above, the subnets for reserved availability zones is not
actually provisioned but its IP space is still reserved. If, in the future,
new availability zones needs to be provisioned, then we would decrement
the value of `reservedAzs` and increment the `maxAzs` or `availabilityZones`
accordingly. This action would not cause the IP address of subnets to get
renumbered, but rather the IP space that was previously reserved will be
used for the new availability zones subnets.

### Advanced Subnet Configuration

If the default VPC configuration (public and private subnets spanning the
size of the VPC) don't suffice for you, you can configure what subnets to
create by specifying the `subnetConfiguration` property. It allows you
to configure the number and size of all subnets. Specifying an advanced
subnet configuration could look like this:

```python
vpc = ec2.Vpc(self, "TheVPC",
    # 'IpAddresses' configures the IP range and size of the entire VPC.
    # The IP space will be divided based on configuration for the subnets.
    ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/21"),

    # 'maxAzs' configures the maximum number of availability zones to use.
    # If you want to specify the exact availability zones you want the VPC
    # to use, use `availabilityZones` instead.
    max_azs=3,

    # 'subnetConfiguration' specifies the "subnet groups" to create.
    # Every subnet group will have a subnet for each AZ, so this
    # configuration will create `3 groups × 3 AZs = 9` subnets.
    subnet_configuration=[ec2.SubnetConfiguration(
        # 'subnetType' controls Internet access, as described above.
        subnet_type=ec2.SubnetType.PUBLIC,

        # 'name' is used to name this particular subnet group. You will have to
        # use the name for subnet selection if you have more than one subnet
        # group of the same type.
        name="Ingress",

        # 'cidrMask' specifies the IP addresses in the range of of individual
        # subnets in the group. Each of the subnets in this group will contain
        # `2^(32 address bits - 24 subnet bits) - 2 reserved addresses = 254`
        # usable IP addresses.
        #
        # If 'cidrMask' is left out the available address space is evenly
        # divided across the remaining subnet groups.
        cidr_mask=24
    ), ec2.SubnetConfiguration(
        cidr_mask=24,
        name="Application",
        subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
    ), ec2.SubnetConfiguration(
        cidr_mask=28,
        name="Database",
        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,

        # 'reserved' can be used to reserve IP address space. No resources will
        # be created for this subnet, but the IP range will be kept available for
        # future creation of this subnet, or even for future subdivision.
        reserved=True
    )
    ]
)
```

The example above is one possible configuration, but the user can use the
constructs above to implement many other network configurations.

The `Vpc` from the above configuration in a Region with three
availability zones will be the following:

Subnet Name       |Type      |IP Block      |AZ|Features
------------------|----------|--------------|--|--------
IngressSubnet1    |`PUBLIC`  |`10.0.0.0/24` |#1|NAT Gateway
IngressSubnet2    |`PUBLIC`  |`10.0.1.0/24` |#2|NAT Gateway
IngressSubnet3    |`PUBLIC`  |`10.0.2.0/24` |#3|NAT Gateway
ApplicationSubnet1|`PRIVATE` |`10.0.3.0/24` |#1|Route to NAT in IngressSubnet1
ApplicationSubnet2|`PRIVATE` |`10.0.4.0/24` |#2|Route to NAT in IngressSubnet2
ApplicationSubnet3|`PRIVATE` |`10.0.5.0/24` |#3|Route to NAT in IngressSubnet3
DatabaseSubnet1   |`ISOLATED`|`10.0.6.0/28` |#1|Only routes within the VPC
DatabaseSubnet2   |`ISOLATED`|`10.0.6.16/28`|#2|Only routes within the VPC
DatabaseSubnet3   |`ISOLATED`|`10.0.6.32/28`|#3|Only routes within the VPC

#### Dual Stack Configurations

Here is a break down of IPv4 and IPv6 specifc `subnetConfiguration` properties in a dual stack VPC:

```python
vpc = ec2.Vpc(self, "TheVPC",
    ip_protocol=ec2.IpProtocol.DUAL_STACK,

    subnet_configuration=[ec2.SubnetConfiguration(
        # general properties
        name="Public",
        subnet_type=ec2.SubnetType.PUBLIC,
        reserved=False,

        # IPv4 specific properties
        map_public_ip_on_launch=True,
        cidr_mask=24,

        # new IPv6 specific property
        ipv6_assign_address_on_creation=True
    )
    ]
)
```

The property `mapPublicIpOnLaunch` controls if a public IPv4 address will be assigned. This defaults to `false` for dual stack VPCs to avoid inadvertant costs of having the public address. However, a public IP must be enabled (or otherwise configured with BYOIP or IPAM) in order for services that rely on the address to function.

The `ipv6AssignAddressOnCreation` property controls the same behavior for the IPv6 address. It defaults to true.

Using IPv6 specific properties in an IPv4 only VPC will result in errors.

### Accessing the Internet Gateway

If you need access to the internet gateway, you can get its ID like so:

```python
# vpc: ec2.Vpc


igw_id = vpc.internet_gateway_id
```

For a VPC with only `ISOLATED` subnets, this value will be undefined.

This is only supported for VPCs created in the stack - currently you're
unable to get the ID for imported VPCs. To do that you'd have to specifically
look up the Internet Gateway by name, which would require knowing the name
beforehand.

This can be useful for configuring routing using a combination of gateways:
for more information see [Routing](#routing) below.

### Disabling the creation of the default internet gateway

If you need to control the creation of the internet gateway explicitly,
you can disable the creation of the default one using the `createInternetGateway`
property:

```python
vpc = ec2.Vpc(self, "VPC",
    create_internet_gateway=False,
    subnet_configuration=[ec2.SubnetConfiguration(
        subnet_type=ec2.SubnetType.PUBLIC,
        name="Public"
    )]
)
```

#### Routing

It's possible to add routes to any subnets using the `addRoute()` method. If for
example you want an isolated subnet to have a static route via the default
Internet Gateway created for the public subnet - perhaps for routing a VPN
connection - you can do so like this:

```python
vpc = ec2.Vpc(self, "VPC",
    subnet_configuration=[ec2.SubnetConfiguration(
        subnet_type=ec2.SubnetType.PUBLIC,
        name="Public"
    ), ec2.SubnetConfiguration(
        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
        name="Isolated"
    )]
)

(vpc.isolated_subnets[0]).add_route("StaticRoute",
    router_id=vpc.internet_gateway_id,
    router_type=ec2.RouterType.GATEWAY,
    destination_cidr_block="8.8.8.8/32"
)
```

*Note that we cast to `Subnet` here because the list of subnets only returns an
`ISubnet`.*

### Reserving subnet IP space

There are situations where the IP space for a subnet or number of subnets
will need to be reserved. This is useful in situations where subnets would
need to be added after the vpc is originally deployed, without causing IP
renumbering for existing subnets. The IP space for a subnet may be reserved
by setting the `reserved` subnetConfiguration property to true, as shown
below:

```python
vpc = ec2.Vpc(self, "TheVPC",
    nat_gateways=1,
    subnet_configuration=[ec2.SubnetConfiguration(
        cidr_mask=26,
        name="Public",
        subnet_type=ec2.SubnetType.PUBLIC
    ), ec2.SubnetConfiguration(
        cidr_mask=26,
        name="Application1",
        subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
    ), ec2.SubnetConfiguration(
        cidr_mask=26,
        name="Application2",
        subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS,
        reserved=True
    ), ec2.SubnetConfiguration(
        cidr_mask=27,
        name="Database",
        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
    )
    ]
)
```

In the example above, the subnet for Application2 is not actually provisioned
but its IP space is still reserved. If in the future this subnet needs to be
provisioned, then the `reserved: true` property should be removed. Reserving
parts of the IP space prevents the other subnets from getting renumbered.

### Sharing VPCs between stacks

If you are creating multiple `Stack`s inside the same CDK application, you
can reuse a VPC defined in one Stack in another by simply passing the VPC
instance around:

```python
#
# Stack1 creates the VPC
#
class Stack1(cdk.Stack):

    def __init__(self, scope, id, *, description=None, env=None, stackName=None, tags=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
        super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)

        self.vpc = ec2.Vpc(self, "VPC")

#
# Stack2 consumes the VPC
#
class Stack2(cdk.Stack):
    def __init__(self, scope, id, *, vpc, description=None, env=None, stackName=None, tags=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None):
        super().__init__(scope, id, vpc=vpc, description=description, env=env, stackName=stackName, tags=tags, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation)

        # Pass the VPC to a construct that needs it
        ConstructThatTakesAVpc(self, "Construct",
            vpc=vpc
        )

stack1 = Stack1(app, "Stack1")
stack2 = Stack2(app, "Stack2",
    vpc=stack1.vpc
)
```

### Importing an existing VPC

If your VPC is created outside your CDK app, you can use `Vpc.fromLookup()`.
The CDK CLI will search for the specified VPC in the the stack's region and
account, and import the subnet configuration. Looking up can be done by VPC
ID, but more flexibly by searching for a specific tag on the VPC.

Subnet types will be determined from the `aws-cdk:subnet-type` tag on the
subnet if it exists, or the presence of a route to an Internet Gateway
otherwise. Subnet names will be determined from the `aws-cdk:subnet-name` tag
on the subnet if it exists, or will mirror the subnet type otherwise (i.e.
a public subnet will have the name `"Public"`).

The result of the `Vpc.fromLookup()` operation will be written to a file
called `cdk.context.json`. You must commit this file to source control so
that the lookup values are available in non-privileged environments such
as CI build steps, and to ensure your template builds are repeatable.

Here's how `Vpc.fromLookup()` can be used:

```python
vpc = ec2.Vpc.from_lookup(stack, "VPC",
    # This imports the default VPC but you can also
    # specify a 'vpcName' or 'tags'.
    is_default=True
)
```

`Vpc.fromLookup` is the recommended way to import VPCs. If for whatever
reason you do not want to use the context mechanism to look up a VPC at
synthesis time, you can also use `Vpc.fromVpcAttributes`. This has the
following limitations:

* Every subnet group in the VPC must have a subnet in each availability zone
  (for example, each AZ must have both a public and private subnet). Asymmetric
  VPCs are not supported.
* All VpcId, SubnetId, RouteTableId, ... parameters must either be known at
  synthesis time, or they must come from deploy-time list parameters whose
  deploy-time lengths are known at synthesis time.

Using `Vpc.fromVpcAttributes()` looks like this:

```python
vpc = ec2.Vpc.from_vpc_attributes(self, "VPC",
    vpc_id="vpc-1234",
    availability_zones=["us-east-1a", "us-east-1b"],

    # Either pass literals for all IDs
    public_subnet_ids=["s-12345", "s-67890"],

    # OR: import a list of known length
    private_subnet_ids=Fn.import_list_value("PrivateSubnetIds", 2),

    # OR: split an imported string to a list of known length
    isolated_subnet_ids=Fn.split(",", ssm.StringParameter.value_for_string_parameter(self, "MyParameter"), 2)
)
```

For each subnet group the import function accepts optional parameters for subnet
names, route table ids and IPv4 CIDR blocks. When supplied, the length of these
lists are required to match the length of the list of subnet ids, allowing the
lists to be zipped together to form `ISubnet` instances.

Public subnet group example (for private or isolated subnet groups, use the properties with the respective prefix):

```python
vpc = ec2.Vpc.from_vpc_attributes(self, "VPC",
    vpc_id="vpc-1234",
    availability_zones=["us-east-1a", "us-east-1b", "us-east-1c"],
    public_subnet_ids=["s-12345", "s-34567", "s-56789"],
    public_subnet_names=["Subnet A", "Subnet B", "Subnet C"],
    public_subnet_route_table_ids=["rt-12345", "rt-34567", "rt-56789"],
    public_subnet_ipv4_cidr_blocks=["10.0.0.0/24", "10.0.1.0/24", "10.0.2.0/24"]
)
```

The above example will create an `IVpc` instance with three public subnets:

| Subnet id | Availability zone | Subnet name | Route table id | IPv4 CIDR   |
| --------- | ----------------- | ----------- | -------------- | ----------- |
| s-12345   | us-east-1a        | Subnet A    | rt-12345       | 10.0.0.0/24 |
| s-34567   | us-east-1b        | Subnet B    | rt-34567       | 10.0.1.0/24 |
| s-56789   | us-east-1c        | Subnet B    | rt-56789       | 10.0.2.0/24 |

### Restricting access to the VPC default security group

AWS Security best practices recommend that the [VPC default security group should
not allow inbound and outbound
traffic](https://docs.aws.amazon.com/securityhub/latest/userguide/ec2-controls.html#ec2-2).
When the `@aws-cdk/aws-ec2:restrictDefaultSecurityGroup` feature flag is set to
`true` (default for new projects) this will be enabled by default. If you do not
have this feature flag set you can either set the feature flag *or* you can set
the `restrictDefaultSecurityGroup` property to `true`.

```python
ec2.Vpc(self, "VPC",
    restrict_default_security_group=True
)
```

If you set this property to `true` and then later remove it or set it to `false`
the default ingress/egress will be restored on the default security group.

## Allowing Connections

In AWS, all network traffic in and out of **Elastic Network Interfaces** (ENIs)
is controlled by **Security Groups**. You can think of Security Groups as a
firewall with a set of rules. By default, Security Groups allow no incoming
(ingress) traffic and all outgoing (egress) traffic. You can add ingress rules
to them to allow incoming traffic streams. To exert fine-grained control over
egress traffic, set `allowAllOutbound: false` on the `SecurityGroup`, after
which you can add egress traffic rules.

You can manipulate Security Groups directly:

```python
my_security_group = ec2.SecurityGroup(self, "SecurityGroup",
    vpc=vpc,
    description="Allow ssh access to ec2 instances",
    allow_all_outbound=True
)
my_security_group.add_ingress_rule(ec2.Peer.any_ipv4(), ec2.Port.tcp(22), "allow ssh access from the world")
```

All constructs that create ENIs on your behalf (typically constructs that create
EC2 instances or other VPC-connected resources) will all have security groups
automatically assigned. Those constructs have an attribute called
**connections**, which is an object that makes it convenient to update the
security groups. If you want to allow connections between two constructs that
have security groups, you have to add an **Egress** rule to one Security Group,
and an **Ingress** rule to the other. The connections object will automatically
take care of this for you:

```python
# load_balancer: elbv2.ApplicationLoadBalancer
# app_fleet: autoscaling.AutoScalingGroup
# db_fleet: autoscaling.AutoScalingGroup


# Allow connections from anywhere
load_balancer.connections.allow_from_any_ipv4(ec2.Port.tcp(443), "Allow inbound HTTPS")

# The same, but an explicit IP address
load_balancer.connections.allow_from(ec2.Peer.ipv4("1.2.3.4/32"), ec2.Port.tcp(443), "Allow inbound HTTPS")

# Allow connection between AutoScalingGroups
app_fleet.connections.allow_to(db_fleet, ec2.Port.tcp(443), "App can call database")
```

### Connection Peers

There are various classes that implement the connection peer part:

```python
# app_fleet: autoscaling.AutoScalingGroup
# db_fleet: autoscaling.AutoScalingGroup


# Simple connection peers
peer = ec2.Peer.ipv4("10.0.0.0/16")
peer = ec2.Peer.any_ipv4()
peer = ec2.Peer.ipv6("::0/0")
peer = ec2.Peer.any_ipv6()
peer = ec2.Peer.prefix_list("pl-12345")
app_fleet.connections.allow_to(peer, ec2.Port.tcp(443), "Allow outbound HTTPS")
```

Any object that has a security group can itself be used as a connection peer:

```python
# fleet1: autoscaling.AutoScalingGroup
# fleet2: autoscaling.AutoScalingGroup
# app_fleet: autoscaling.AutoScalingGroup


# These automatically create appropriate ingress and egress rules in both security groups
fleet1.connections.allow_to(fleet2, ec2.Port.tcp(80), "Allow between fleets")

app_fleet.connections.allow_from_any_ipv4(ec2.Port.tcp(80), "Allow from load balancer")
```

### Port Ranges

The connections that are allowed are specified by port ranges. A number of classes provide
the connection specifier:

```python
ec2.Port.tcp(80)
ec2.Port.tcp_range(60000, 65535)
ec2.Port.all_tcp()
ec2.Port.all_icmp()
ec2.Port.all_icmp_v6()
ec2.Port.all_traffic()
```

> NOTE: Not all protocols have corresponding helper methods. In the absence of a helper method,
> you can instantiate `Port` yourself with your own settings. You are also welcome to contribute
> new helper methods.

### Default Ports

Some Constructs have default ports associated with them. For example, the
listener of a load balancer does (it's the public port), or instances of an
RDS database (it's the port the database is accepting connections on).

If the object you're calling the peering method on has a default port associated with it, you can call
`allowDefaultPortFrom()` and omit the port specifier. If the argument has an associated default port, call
`allowDefaultPortTo()`.

For example:

```python
# listener: elbv2.ApplicationListener
# app_fleet: autoscaling.AutoScalingGroup
# rds_database: rds.DatabaseCluster


# Port implicit in listener
listener.connections.allow_default_port_from_any_ipv4("Allow public")

# Port implicit in peer
app_fleet.connections.allow_default_port_to(rds_database, "Fleet can access database")
```

### Security group rules

By default, security group wills be added inline to the security group in the output cloud formation
template, if applicable.  This includes any static rules by ip address and port range.  This
optimization helps to minimize the size of the template.

In some environments this is not desirable, for example if your security group access is controlled
via tags. You can disable inline rules per security group or globally via the context key
`@aws-cdk/aws-ec2.securityGroupDisableInlineRules`.

```python
my_security_group_without_inline_rules = ec2.SecurityGroup(self, "SecurityGroup",
    vpc=vpc,
    description="Allow ssh access to ec2 instances",
    allow_all_outbound=True,
    disable_inline_rules=True
)
# This will add the rule as an external cloud formation construct
my_security_group_without_inline_rules.add_ingress_rule(ec2.Peer.any_ipv4(), ec2.Port.tcp(22), "allow ssh access from the world")
```

### Importing an existing security group

If you know the ID and the configuration of the security group to import, you can use `SecurityGroup.fromSecurityGroupId`:

```python
sg = ec2.SecurityGroup.from_security_group_id(self, "SecurityGroupImport", "sg-1234",
    allow_all_outbound=True
)
```

Alternatively, use lookup methods to import security groups if you do not know the ID or the configuration details. Method `SecurityGroup.fromLookupByName` looks up a security group if the security group ID is unknown.

```python
sg = ec2.SecurityGroup.from_lookup_by_name(self, "SecurityGroupLookup", "security-group-name", vpc)
```

If the security group ID is known and configuration details are unknown, use method `SecurityGroup.fromLookupById` instead. This method will lookup property `allowAllOutbound` from the current configuration of the security group.

```python
sg = ec2.SecurityGroup.from_lookup_by_id(self, "SecurityGroupLookup", "sg-1234")
```

The result of `SecurityGroup.fromLookupByName` and `SecurityGroup.fromLookupById` operations will be written to a file called `cdk.context.json`. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.

### Cross Stack Connections

If you are attempting to add a connection from a peer in one stack to a peer in a different stack, sometimes it is necessary to ensure that you are making the connection in
a specific stack in order to avoid a cyclic reference. If there are no other dependencies between stacks then it will not matter in which stack you make
the connection, but if there are existing dependencies (i.e. stack1 already depends on stack2), then it is important to make the connection in the dependent stack (i.e. stack1).

Whenever you make a `connections` function call, the ingress and egress security group rules will be added to the stack that the calling object exists in.
So if you are doing something like `peer1.connections.allowFrom(peer2)`, then the security group rules (both ingress and egress) will be created in `peer1`'s Stack.

As an example, if we wanted to allow a connection from a security group in one stack (egress) to a security group in a different stack (ingress),
we would make the connection like:

**If Stack1 depends on Stack2**

```python
# Stack 1
# stack1: Stack
# stack2: Stack


sg1 = ec2.SecurityGroup(stack1, "SG1",
    allow_all_outbound=False,  # if this is `true` then no egress rule will be created
    vpc=vpc
)

# Stack 2
sg2 = ec2.SecurityGroup(stack2, "SG2",
    allow_all_outbound=False,  # if this is `true` then no egress rule will be created
    vpc=vpc
)

# `connections.allowTo` on `sg1` since we want the
# rules to be created in Stack1
sg1.connections.allow_to(sg2, ec2.Port.tcp(3333))
```

In this case both the Ingress Rule for `sg2` and the Egress Rule for `sg1` will both be created
in `Stack 1` which avoids the cyclic reference.

**If Stack2 depends on Stack1**

```python
# Stack 1
# stack1: Stack
# stack2: Stack


sg1 = ec2.SecurityGroup(stack1, "SG1",
    allow_all_outbound=False,  # if this is `true` then no egress rule will be created
    vpc=vpc
)

# Stack 2
sg2 = ec2.SecurityGroup(stack2, "SG2",
    allow_all_outbound=False,  # if this is `true` then no egress rule will be created
    vpc=vpc
)

# `connections.allowFrom` on `sg2` since we want the
# rules to be created in Stack2
sg2.connections.allow_from(sg1, ec2.Port.tcp(3333))
```

In this case both the Ingress Rule for `sg2` and the Egress Rule for `sg1` will both be created
in `Stack 2` which avoids the cyclic reference.

## Machine Images (AMIs)

AMIs control the OS that gets launched when you start your EC2 instance. The EC2
library contains constructs to select the AMI you want to use.

Depending on the type of AMI, you select it a different way. Here are some
examples of images you might want to use:

```python
# Pick the right Amazon Linux edition. All arguments shown are optional
# and will default to these values when omitted.
amzn_linux = ec2.MachineImage.latest_amazon_linux(
    generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
    edition=ec2.AmazonLinuxEdition.STANDARD,
    virtualization=ec2.AmazonLinuxVirt.HVM,
    storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE,
    cpu_type=ec2.AmazonLinuxCpuType.X86_64
)

# Pick a Windows edition to use
windows = ec2.MachineImage.latest_windows(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)

# Read AMI id from SSM parameter store
ssm = ec2.MachineImage.from_ssm_parameter("/my/ami", os=ec2.OperatingSystemType.LINUX)

# Look up the most recent image matching a set of AMI filters.
# In this case, look up the NAT instance AMI, by using a wildcard
# in the 'name' field:
nat_ami = ec2.MachineImage.lookup(
    name="amzn-ami-vpc-nat-*",
    owners=["amazon"]
)

# For other custom (Linux) images, instantiate a `GenericLinuxImage` with
# a map giving the AMI to in for each region:
linux = ec2.MachineImage.generic_linux({
    "us-east-1": "ami-97785bed",
    "eu-west-1": "ami-12345678"
})

# For other custom (Windows) images, instantiate a `GenericWindowsImage` with
# a map giving the AMI to in for each region:
generic_windows = ec2.MachineImage.generic_windows({
    "us-east-1": "ami-97785bed",
    "eu-west-1": "ami-12345678"
})
```

> NOTE: The AMIs selected by `MachineImage.lookup()` will be cached in
> `cdk.context.json`, so that your AutoScalingGroup instances aren't replaced while
> you are making unrelated changes to your CDK app.
>
> To query for the latest AMI again, remove the relevant cache entry from
> `cdk.context.json`, or use the `cdk context` command. For more information, see
> [Runtime Context](https://docs.aws.amazon.com/cdk/latest/guide/context.html) in the CDK
> developer guide.
>
> `MachineImage.genericLinux()`, `MachineImage.genericWindows()` will use `CfnMapping` in
> an agnostic stack.

## Special VPC configurations

### VPN connections to a VPC

Create your VPC with VPN connections by specifying the `vpnConnections` props (keys are construct `id`s):

```python
from aws_cdk import SecretValue


vpc = ec2.Vpc(self, "MyVpc",
    vpn_connections={
        "dynamic": ec2.VpnConnectionOptions( # Dynamic routing (BGP)
            ip="1.2.3.4",
            tunnel_options=[ec2.VpnTunnelOption(
                pre_shared_key_secret=SecretValue.unsafe_plain_text("secretkey1234")
            ), ec2.VpnTunnelOption(
                pre_shared_key_secret=SecretValue.unsafe_plain_text("secretkey5678")
            )
            ]),
        "static": ec2.VpnConnectionOptions( # Static routing
            ip="4.5.6.7",
            static_routes=["192.168.10.0/24", "192.168.20.0/24"
            ])
    }
)
```

To create a VPC that can accept VPN connections, set `vpnGateway` to `true`:

```python
vpc = ec2.Vpc(self, "MyVpc",
    vpn_gateway=True
)
```

VPN connections can then be added:

```python
vpc.add_vpn_connection("Dynamic",
    ip="1.2.3.4"
)
```

By default, routes will be propagated on the route tables associated with the private subnets. If no
private subnets exist, isolated subnets are used. If no isolated subnets exist, public subnets are
used. Use the `Vpc` property `vpnRoutePropagation` to customize this behavior.

VPN connections expose [metrics (cloudwatch.Metric)](https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/aws-cloudwatch/README.md) across all tunnels in the account/region and per connection:

```python
# Across all tunnels in the account/region
all_data_out = ec2.VpnConnection.metric_all_tunnel_data_out()

# For a specific vpn connection
vpn_connection = vpc.add_vpn_connection("Dynamic",
    ip="1.2.3.4"
)
state = vpn_connection.metric_tunnel_state()
```

### VPC endpoints

A VPC endpoint enables you to privately connect your VPC to supported AWS services and VPC endpoint services powered by PrivateLink without requiring an internet gateway, NAT device, VPN connection, or AWS Direct Connect connection. Instances in your VPC do not require public IP addresses to communicate with resources in the service. Traffic between your VPC and the other service does not leave the Amazon network.

Endpoints are virtual devices. They are horizontally scaled, redundant, and highly available VPC components that allow communication between instances in your VPC and services without imposing availability risks or bandwidth constraints on your network traffic.

```python
# Add gateway endpoints when creating the VPC
vpc = ec2.Vpc(self, "MyVpc",
    gateway_endpoints={
        "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
            service=ec2.GatewayVpcEndpointAwsService.S3
        )
    }
)

# Alternatively gateway endpoints can be added on the VPC
dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
    service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
)

# This allows to customize the endpoint policy
dynamo_db_endpoint.add_to_policy(
    iam.PolicyStatement( # Restrict to listing and describing tables
        principals=[iam.AnyPrincipal()],
        actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
        resources=["*"]))

# Add an interface endpoint
vpc.add_interface_endpoint("EcrDockerEndpoint",
    service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
)
```

By default, CDK will place a VPC endpoint in one subnet per AZ. If you wish to override the AZs CDK places the VPC endpoint in,
use the `subnets` parameter as follows:

```python
# vpc: ec2.Vpc


ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
    vpc=vpc,
    service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
    # Choose which availability zones to place the VPC endpoint in, based on
    # available AZs
    subnets=ec2.SubnetSelection(
        availability_zones=["us-east-1a", "us-east-1c"]
    )
)
```

Per the [AWS documentation](https://aws.amazon.com/premiumsupport/knowledge-center/interface-endpoint-availability-zone/), not all
VPC endpoint services are available in all AZs. If you specify the parameter `lookupSupportedAzs`, CDK attempts to discover which
AZs an endpoint service is available in, and will ensure the VPC endpoint is not placed in a subnet that doesn't match those AZs.
These AZs will be stored in cdk.context.json.

```python
# vpc: ec2.Vpc


ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
    vpc=vpc,
    service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
    # Choose which availability zones to place the VPC endpoint in, based on
    # available AZs
    lookup_supported_azs=True
)
```

Pre-defined AWS services are defined in the [InterfaceVpcEndpointAwsService](lib/vpc-endpoint.ts) class, and can be used to
create VPC endpoints without having to configure name, ports, etc. For example, a Keyspaces endpoint can be created for
use in your VPC:

```python
# vpc: ec2.Vpc


ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
    vpc=vpc,
    service=ec2.InterfaceVpcEndpointAwsService.KEYSPACES
)
```

#### Security groups for interface VPC endpoints

By default, interface VPC endpoints create a new security group and all traffic to the endpoint from within the VPC will be automatically allowed.

Use the `connections` object to allow other traffic to flow to the endpoint:

```python
# my_endpoint: ec2.InterfaceVpcEndpoint


my_endpoint.connections.allow_default_port_from_any_ipv4()
```

Alternatively, existing security groups can be used by specifying the `securityGroups` prop.

### VPC endpoint services

A VPC endpoint service enables you to expose a Network Load Balancer(s) as a provider service to consumers, who connect to your service over a VPC endpoint. You can restrict access to your service via allowed principals (anything that extends ArnPrincipal), and require that new connections be manually accepted. You can also enable Contributor Insight rules.

```python
# network_load_balancer1: elbv2.NetworkLoadBalancer
# network_load_balancer2: elbv2.NetworkLoadBalancer


ec2.VpcEndpointService(self, "EndpointService",
    vpc_endpoint_service_load_balancers=[network_load_balancer1, network_load_balancer2],
    acceptance_required=True,
    allowed_principals=[iam.ArnPrincipal("arn:aws:iam::123456789012:root")],
    contributor_insights=True
)
```

Endpoint services support private DNS, which makes it easier for clients to connect to your service by automatically setting up DNS in their VPC.
You can enable private DNS on an endpoint service like so:

```python
from aws_cdk.aws_route53 import PublicHostedZone, VpcEndpointServiceDomainName
# zone: PublicHostedZone
# vpces: ec2.VpcEndpointService


VpcEndpointServiceDomainName(self, "EndpointDomain",
    endpoint_service=vpces,
    domain_name="my-stuff.aws-cdk.dev",
    public_hosted_zone=zone
)
```

Note: The domain name must be owned (registered through Route53) by the account the endpoint service is in, or delegated to the account.
The VpcEndpointServiceDomainName will handle the AWS side of domain verification, the process for which can be found
[here](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-dns-validation.html)

### Client VPN endpoint

AWS Client VPN is a managed client-based VPN service that enables you to securely access your AWS
resources and resources in your on-premises network. With Client VPN, you can access your resources
from any location using an OpenVPN-based VPN client.

Use the `addClientVpnEndpoint()` method to add a client VPN endpoint to a VPC:

```python
vpc.add_client_vpn_endpoint("Endpoint",
    cidr="10.100.0.0/16",
    server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
    # Mutual authentication
    client_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/client-certificate-id",
    # User-based authentication
    user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider)
)
```

The endpoint must use at least one [authentication method](https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/client-authentication.html):

* Mutual authentication with a client certificate
* User-based authentication (directory or federated)

If user-based authentication is used, the [self-service portal URL](https://docs.aws.amazon.com/vpn/latest/clientvpn-user/self-service-portal.html)
is made available via a CloudFormation output.

By default, a new security group is created, and logging is enabled. Moreover, a rule to
authorize all users to the VPC CIDR is created.

To customize authorization rules, set the `authorizeAllUsersToVpcCidr` prop to `false`
and use `addAuthorizationRule()`:

```python
endpoint = vpc.add_client_vpn_endpoint("Endpoint",
    cidr="10.100.0.0/16",
    server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
    user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider),
    authorize_all_users_to_vpc_cidr=False
)

endpoint.add_authorization_rule("Rule",
    cidr="10.0.10.0/32",
    group_id="group-id"
)
```

Use `addRoute()` to configure network routes:

```python
endpoint = vpc.add_client_vpn_endpoint("Endpoint",
    cidr="10.100.0.0/16",
    server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
    user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider)
)

# Client-to-client access
endpoint.add_route("Route",
    cidr="10.100.0.0/16",
    target=ec2.ClientVpnRouteTarget.local()
)
```

Use the `connections` object of the endpoint to allow traffic to other security groups.

## Instances

You can use the `Instance` class to start up a single EC2 instance. For production setups, we recommend
you use an `AutoScalingGroup` from the `aws-autoscaling` module instead, as AutoScalingGroups will take
care of restarting your instance if it ever fails.

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType


# Amazon Linux 2
ec2.Instance(self, "Instance2",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2()
)

# Amazon Linux 2 with kernel 5.x
ec2.Instance(self, "Instance3",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2(
        kernel=ec2.AmazonLinux2Kernel.KERNEL_5_10
    )
)

# Amazon Linux 2023
ec2.Instance(self, "Instance4",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2023()
)

# Graviton 3 Processor
ec2.Instance(self, "Instance5",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    machine_image=ec2.MachineImage.latest_amazon_linux2023(
        cpu_type=ec2.AmazonLinuxCpuType.ARM_64
    )
)
```

### Latest Amazon Linux Images

Rather than specifying a specific AMI ID to use, it is possible to specify a SSM
Parameter that contains the AMI ID. AWS publishes a set of [public parameters](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-public-parameters-ami.html)
that contain the latest Amazon Linux AMIs. To make it easier to query a
particular image parameter, the CDK provides a couple of constructs `AmazonLinux2ImageSsmParameter`,
`AmazonLinux2022ImageSsmParameter`, & `AmazonLinux2023SsmParameter`. For example
to use the latest `al2023` image:

```python
# vpc: ec2.Vpc


ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    machine_image=ec2.MachineImage.latest_amazon_linux2023()
)
```

> **Warning**
> Since this retrieves the value from an SSM parameter at deployment time, the
> value will be resolved each time the stack is deployed. This means that if
> the parameter contains a different value on your next deployment, the instance
> will be replaced.

It is also possible to perform the lookup once at synthesis time and then cache
the value in CDK context. This way the value will not change on future
deployments unless you manually refresh the context.

```python
# vpc: ec2.Vpc


ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    machine_image=ec2.MachineImage.latest_amazon_linux2023(
        cached_in_context=True
    )
)

# or
ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    # context cache is turned on by default
    machine_image=ec2.AmazonLinux2023ImageSsmParameter()
)
```

#### Kernel Versions

Each Amazon Linux AMI uses a specific kernel version. Most Amazon Linux
generations come with an AMI using the "default" kernel and then 1 or more
AMIs using a specific kernel version, which may or may not be different from the
default kernel version.

For example, Amazon Linux 2 has two different AMIs available from the SSM
parameters.

* `/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-ebs`

  * This is the "default" kernel which uses `kernel-4.14`
* `/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-ebs`

If a new Amazon Linux generation AMI is published with a new kernel version,
then a new SSM parameter will be created with the new version
(e.g. `/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.15-hvm-x86_64-ebs`),
but the "default" AMI may or may not be updated.

If you would like to make sure you always have the latest kernel version, then
either specify the specific latest kernel version or opt-in to using the CDK
latest kernel version.

```python
# vpc: ec2.Vpc


ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    # context cache is turned on by default
    machine_image=ec2.AmazonLinux2023ImageSsmParameter(
        kernel=ec2.AmazonLinux2023Kernel.KERNEL_6_1
    )
)
```

*CDK managed latest*

```python
# vpc: ec2.Vpc


ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    # context cache is turned on by default
    machine_image=ec2.AmazonLinux2023ImageSsmParameter(
        kernel=ec2.AmazonLinux2023Kernel.CDK_LATEST
    )
)

# or

ec2.Instance(self, "LatestAl2023",
    vpc=vpc,
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
    machine_image=ec2.MachineImage.latest_amazon_linux2023()
)
```

When using the CDK managed latest version, when a new kernel version is made
available the `LATEST` will be updated to point to the new kernel version. You
then would be required to update the newest CDK version for it to take effect.

### Configuring Instances using CloudFormation Init (cfn-init)

CloudFormation Init allows you to configure your instances by writing files to them, installing software
packages, starting services and running arbitrary commands. By default, if any of the instance setup
commands throw an error; the deployment will fail and roll back to the previously known good state.
The following documentation also applies to `AutoScalingGroup`s.

For the full set of capabilities of this system, see the documentation for
[`AWS::CloudFormation::Init`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html).
Here is an example of applying some configuration to an instance:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType
# machine_image: ec2.IMachineImage


ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=machine_image,

    # Showing the most complex setup, if you have simpler requirements
    # you can use `CloudFormationInit.fromElements()`.
    init=ec2.CloudFormationInit.from_config_sets(
        config_sets={
            # Applies the configs below in this order
            "default": ["yumPreinstall", "config"]
        },
        configs={
            "yum_preinstall": ec2.InitConfig([
                # Install an Amazon Linux package using yum
                ec2.InitPackage.yum("git")
            ]),
            "config": ec2.InitConfig([
                # Create a JSON file from tokens (can also create other files)
                ec2.InitFile.from_object("/etc/stack.json", {
                    "stack_id": Stack.of(self).stack_id,
                    "stack_name": Stack.of(self).stack_name,
                    "region": Stack.of(self).region
                }),

                # Create a group and user
                ec2.InitGroup.from_name("my-group"),
                ec2.InitUser.from_name("my-user"),

                # Install an RPM from the internet
                ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
            ])
        }
    ),
    init_options=ec2.ApplyCloudFormationInitOptions(
        # Optional, which configsets to activate (['default'] by default)
        config_sets=["default"],

        # Optional, how long the installation is expected to take (5 minutes by default)
        timeout=Duration.minutes(30),

        # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
        include_url=True,

        # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
        include_role=True
    )
)
```

`InitCommand` can not be used to start long-running processes. At deploy time,
`cfn-init` will always wait for the process to exit before continuing, causing
the CloudFormation deployment to fail because the signal hasn't been received
within the expected timeout.

Instead, you should install a service configuration file onto your machine `InitFile`,
and then use `InitService` to start it.

If your Linux OS is using SystemD (like Amazon Linux 2 or higher), the CDK has
helpers to create a long-running service using CFN Init. You can create a
SystemD-compatible config file using `InitService.systemdConfigFile()`, and
start it immediately. The following examples shows how to start a trivial Python
3 web server:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType


ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),

    init=ec2.CloudFormationInit.from_elements(
        # Create a simple config file that runs a Python web server
        ec2.InitService.systemd_config_file("simpleserver",
            command="/usr/bin/python3 -m http.server 8080",
            cwd="/var/www/html"
        ),
        # Start the server using SystemD
        ec2.InitService.enable("simpleserver",
            service_manager=ec2.ServiceManager.SYSTEMD
        ),
        # Drop an example file to show the web server working
        ec2.InitFile.from_string("/var/www/html/index.html", "Hello! It's working!"))
)
```

You can have services restarted after the init process has made changes to the system.
To do that, instantiate an `InitServiceRestartHandle` and pass it to the config elements
that need to trigger the restart and the service itself. For example, the following
config writes a config file for nginx, extracts an archive to the root directory, and then
restarts nginx so that it picks up the new config and files:

```python
# my_bucket: s3.Bucket


handle = ec2.InitServiceRestartHandle()

ec2.CloudFormationInit.from_elements(
    ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
    ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
    ec2.InitService.enable("nginx",
        service_restart_handle=handle
    ))
```

### Bastion Hosts

A bastion host functions as an instance used to access servers and resources in a VPC without open up the complete VPC on a network level.
You can use bastion hosts using a standard SSH connection targeting port 22 on the host. As an alternative, you can connect the SSH connection
feature of AWS Systems Manager Session Manager, which does not need an opened security group. (https://aws.amazon.com/about-aws/whats-new/2019/07/session-manager-launches-tunneling-support-for-ssh-and-scp/)

A default bastion host for use via SSM can be configured like:

```python
host = ec2.BastionHostLinux(self, "BastionHost", vpc=vpc)
```

If you want to connect from the internet using SSH, you need to place the host into a public subnet. You can then configure allowed source hosts.

```python
host = ec2.BastionHostLinux(self, "BastionHost",
    vpc=vpc,
    subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC)
)
host.allow_ssh_access_from(ec2.Peer.ipv4("1.2.3.4/32"))
```

As there are no SSH public keys deployed on this machine, you need to use [EC2 Instance Connect](https://aws.amazon.com/de/blogs/compute/new-using-amazon-ec2-instance-connect-for-ssh-access-to-your-ec2-instances/)
with the command `aws ec2-instance-connect send-ssh-public-key` to provide your SSH public key.

EBS volume for the bastion host can be encrypted like:

```python
host = ec2.BastionHostLinux(self, "BastionHost",
    vpc=vpc,
    block_devices=[ec2.BlockDevice(
        device_name="EBSBastionHost",
        volume=ec2.BlockDeviceVolume.ebs(10,
            encrypted=True
        )
    )]
)
```

### Block Devices

To add EBS block device mappings, specify the `blockDevices` property. The following example sets the EBS-backed
root device (`/dev/sda1`) size to 50 GiB, and adds another EBS-backed device mapped to `/dev/sdm` that is 100 GiB in
size:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType
# machine_image: ec2.IMachineImage


ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=machine_image,

    # ...

    block_devices=[ec2.BlockDevice(
        device_name="/dev/sda1",
        volume=ec2.BlockDeviceVolume.ebs(50)
    ), ec2.BlockDevice(
        device_name="/dev/sdm",
        volume=ec2.BlockDeviceVolume.ebs(100)
    )
    ]
)
```

It is also possible to encrypt the block devices. In this example we will create an customer managed key encrypted EBS-backed root device:

```python
from aws_cdk.aws_kms import Key

# vpc: ec2.Vpc
# instance_type: ec2.InstanceType
# machine_image: ec2.IMachineImage


kms_key = Key(self, "KmsKey")

ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=machine_image,

    # ...

    block_devices=[ec2.BlockDevice(
        device_name="/dev/sda1",
        volume=ec2.BlockDeviceVolume.ebs(50,
            encrypted=True,
            kms_key=kms_key
        )
    )
    ]
)
```

### Volumes

Whereas a `BlockDeviceVolume` is an EBS volume that is created and destroyed as part of the creation and destruction of a specific instance. A `Volume` is for when you want an EBS volume separate from any particular instance. A `Volume` is an EBS block device that can be attached to, or detached from, any instance at any time. Some types of `Volume`s can also be attached to multiple instances at the same time to allow you to have shared storage between those instances.

A notable restriction is that a Volume can only be attached to instances in the same availability zone as the Volume itself.

The following demonstrates how to create a 500 GiB encrypted Volume in the `us-west-2a` availability zone, and give a role the ability to attach that Volume to a specific instance:

```python
# instance: ec2.Instance
# role: iam.Role


volume = ec2.Volume(self, "Volume",
    availability_zone="us-west-2a",
    size=Size.gibibytes(500),
    encrypted=True
)

volume.grant_attach_volume(role, [instance])
```

#### Instances Attaching Volumes to Themselves

If you need to grant an instance the ability to attach/detach an EBS volume to/from itself, then using `grantAttachVolume` and `grantDetachVolume` as outlined above
will lead to an unresolvable circular reference between the instance role and the instance. In this case, use `grantAttachVolumeByResourceTag` and `grantDetachVolumeByResourceTag` as follows:

```python
# instance: ec2.Instance
# volume: ec2.Volume


attach_grant = volume.grant_attach_volume_by_resource_tag(instance.grant_principal, [instance])
detach_grant = volume.grant_detach_volume_by_resource_tag(instance.grant_principal, [instance])
```

#### Attaching Volumes

The Amazon EC2 documentation for
[Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) and
[Windows Instances](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ebs-volumes.html) contains information on how
to attach and detach your Volumes to/from instances, and how to format them for use.

The following is a sample skeleton of EC2 UserData that can be used to attach a Volume to the Linux instance that it is running on:

```python
# instance: ec2.Instance
# volume: ec2.Volume


volume.grant_attach_volume_by_resource_tag(instance.grant_principal, [instance])
target_device = "/dev/xvdz"
instance.user_data.add_commands("TOKEN=$(curl -SsfX PUT \"http://169.254.169.254/latest/api/token\" -H \"X-aws-ec2-metadata-token-ttl-seconds: 21600\")", "INSTANCE_ID=$(curl -SsfH \"X-aws-ec2-metadata-token: $TOKEN\" http://169.254.169.254/latest/meta-data/instance-id)", f"aws --region {Stack.of(this).region} ec2 attach-volume --volume-id {volume.volumeId} --instance-id $INSTANCE_ID --device {targetDevice}", f"while ! test -e {targetDevice}; do sleep 1; done")
```

#### Tagging Volumes

You can configure [tag propagation on volume creation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html#cfn-ec2-instance-propagatetagstovolumeoncreation).

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType
# machine_image: ec2.IMachineImage


ec2.Instance(self, "Instance",
    vpc=vpc,
    machine_image=machine_image,
    instance_type=instance_type,
    propagate_tags_to_volume_on_creation=True
)
```

#### Throughput on GP3 Volumes

You can specify the `throughput` of a GP3 volume from 125 (default) to 1000.

```python
ec2.Volume(self, "Volume",
    availability_zone="us-east-1a",
    size=Size.gibibytes(125),
    volume_type=ec2.EbsDeviceVolumeType.GP3,
    throughput=125
)
```

### Configuring Instance Metadata Service (IMDS)

#### Toggling IMDSv1

You can configure [EC2 Instance Metadata Service](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) options to either
allow both IMDSv1 and IMDSv2 or enforce IMDSv2 when interacting with the IMDS.

To do this for a single `Instance`, you can use the `requireImdsv2` property.
The example below demonstrates IMDSv2 being required on a single `Instance`:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType
# machine_image: ec2.IMachineImage


ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=machine_image,

    # ...

    require_imdsv2=True
)
```

You can also use the either the `InstanceRequireImdsv2Aspect` for EC2 instances or the `LaunchTemplateRequireImdsv2Aspect` for EC2 launch templates
to apply the operation to multiple instances or launch templates, respectively.

The following example demonstrates how to use the `InstanceRequireImdsv2Aspect` to require IMDSv2 for all EC2 instances in a stack:

```python
aspect = ec2.InstanceRequireImdsv2Aspect()
Aspects.of(self).add(aspect)
```

### Associating a Public IP Address with an Instance

All subnets have an attribute that determines whether instances launched into that subnet are assigned a public IPv4 address. This attribute is set to true by default for default public subnets. Thus, an EC2 instance launched into a default public subnet will be assigned a public IPv4 address. Nondefault public subnets have this attribute set to false by default and any EC2 instance launched into a nondefault public subnet will not be assigned a public IPv4 address automatically. To automatically assign a public IPv4 address to an instance launched into a nondefault public subnet, you can set the `associatePublicIpAddress` property on the `Instance` construct to true. Alternatively, to not automatically assign a public IPv4 address to an instance launched into a default public subnet, you can set `associatePublicIpAddress` to false. Including this property, removing this property, or updating the value of this property on an existing instance will result in replacement of the instance.

```python
vpc = ec2.Vpc(self, "VPC",
    cidr="10.0.0.0/16",
    nat_gateways=0,
    max_azs=3,
    subnet_configuration=[ec2.SubnetConfiguration(
        name="public-subnet-1",
        subnet_type=ec2.SubnetType.PUBLIC,
        cidr_mask=24
    )
    ]
)

instance = ec2.Instance(self, "Instance",
    vpc=vpc,
    vpc_subnets=ec2.SubnetSelection(subnet_group_name="public-subnet-1"),
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.NANO),
    machine_image=ec2.AmazonLinuxImage(generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2),
    detailed_monitoring=True,
    associate_public_ip_address=True
)
```

### Specifying a key pair

To allow SSH access to an EC2 instance by default, a Key Pair must be specified. Key pairs can
be provided with the `keyPair` property to instances and launch templates. You can create a
key pair for an instance like this:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType


key_pair = ec2.KeyPair(self, "KeyPair",
    type=ec2.KeyPairType.ED25519,
    format=ec2.KeyPairFormat.PEM
)
instance = ec2.Instance(self, "Instance",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),
    # Use the custom key pair
    key_pair=key_pair
)
```

When a new EC2 Key Pair is created (without imported material), the private key material is
automatically stored in Systems Manager Parameter Store. This can be retrieved from the key pair
construct:

```python
key_pair = ec2.KeyPair(self, "KeyPair")
private_key = key_pair.private_key
```

If you already have an SSH key that you wish to use in EC2, that can be provided when constructing the
`KeyPair`. If public key material is provided, the key pair is considered "imported" and there
will not be any data automatically stored in Systems Manager Parameter Store and the `type` property
cannot be specified for the key pair.

```python
key_pair = ec2.KeyPair(self, "KeyPair",
    public_key_material="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIB7jpNzG+YG0s+xIGWbxrxIZiiozHOEuzIJacvASP0mq"
)
```

#### Using an existing EC2 Key Pair

If you already have an EC2 Key Pair created outside of the CDK, you can import that key to
your CDK stack.

You can import it purely by name:

```python
key_pair = ec2.KeyPair.from_key_pair_name(self, "KeyPair", "the-keypair-name")
```

Or by specifying additional attributes:

```python
key_pair = ec2.KeyPair.from_key_pair_attributes(self, "KeyPair",
    key_pair_name="the-keypair-name",
    type=ec2.KeyPairType.RSA
)
```

### Using IPv6 IPs

Instances can be given IPv6 IPs by launching them into a subnet of a dual stack VPC.

```python
vpc = ec2.Vpc(self, "Ip6VpcDualStack",
    ip_protocol=ec2.IpProtocol.DUAL_STACK,
    subnet_configuration=[ec2.SubnetConfiguration(
        name="Public",
        subnet_type=ec2.SubnetType.PUBLIC,
        map_public_ip_on_launch=True
    ), ec2.SubnetConfiguration(
        name="Private",
        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
    )
    ]
)

instance = ec2.Instance(self, "MyInstance",
    instance_type=ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.MICRO),
    machine_image=ec2.MachineImage.latest_amazon_linux2(),
    vpc=vpc,
    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
    allow_all_ipv6_outbound=True
)

instance.connections.allow_from(ec2.Peer.any_ipv6(), ec2.Port.all_icmp_v6(), "allow ICMPv6")
```

Note to set `mapPublicIpOnLaunch` to true in the `subnetConfiguration`.

Additionally, IPv6 support varies by instance type. Most instance types have IPv6 support with exception of m1-m3, c1, g2, and t1.micro. A full list can be found here: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI.

## VPC Flow Logs

VPC Flow Logs is a feature that enables you to capture information about the IP traffic going to and from network interfaces in your VPC. Flow log data can be published to Amazon CloudWatch Logs and Amazon S3. After you've created a flow log, you can retrieve and view its data in the chosen destination. ([https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)).

By default, a flow log will be created with CloudWatch Logs as the destination.

You can create a flow log like this:

```python
# vpc: ec2.Vpc


ec2.FlowLog(self, "FlowLog",
    resource_type=ec2.FlowLogResourceType.from_vpc(vpc)
)
```

Or you can add a Flow Log to a VPC by using the addFlowLog method like this:

```python
vpc = ec2.Vpc(self, "Vpc")

vpc.add_flow_log("FlowLog")
```

You can also add multiple flow logs with different destinations.

```python
vpc = ec2.Vpc(self, "Vpc")

vpc.add_flow_log("FlowLogS3",
    destination=ec2.FlowLogDestination.to_s3()
)

# Only reject traffic and interval every minute.
vpc.add_flow_log("FlowLogCloudWatch",
    traffic_type=ec2.FlowLogTrafficType.REJECT,
    max_aggregation_interval=ec2.FlowLogMaxAggregationInterval.ONE_MINUTE
)
```

To create a Transit Gateway flow log, you can use the `fromTransitGatewayId` method:

```python
# tgw: ec2.CfnTransitGateway


ec2.FlowLog(self, "TransitGatewayFlowLog",
    resource_type=ec2.FlowLogResourceType.from_transit_gateway_id(tgw.ref)
)
```

To create a Transit Gateway Attachment flow log, you can use the `fromTransitGatewayAttachmentId` method:

```python
# tgw_attachment: ec2.CfnTransitGatewayAttachment


ec2.FlowLog(self, "TransitGatewayAttachmentFlowLog",
    resource_type=ec2.FlowLogResourceType.from_transit_gateway_attachment_id(tgw_attachment.ref)
)
```

For flow logs targeting TransitGateway and TransitGatewayAttachment, specifying the `trafficType` is not possible.

### Custom Formatting

You can also custom format flow logs.

```python
vpc = ec2.Vpc(self, "Vpc")

vpc.add_flow_log("FlowLog",
    log_format=[ec2.LogFormat.DST_PORT, ec2.LogFormat.SRC_PORT
    ]
)

# If you just want to add a field to the default field
vpc.add_flow_log("FlowLog",
    log_format=[ec2.LogFormat.VERSION, ec2.LogFormat.ALL_DEFAULT_FIELDS
    ]
)

# If AWS CDK does not support the new fields
vpc.add_flow_log("FlowLog",
    log_format=[ec2.LogFormat.SRC_PORT,
        ec2.LogFormat.custom("${new-field}")
    ]
)
```

By default, the CDK will create the necessary resources for the destination. For the CloudWatch Logs destination
it will create a CloudWatch Logs Log Group as well as the IAM role with the necessary permissions to publish to
the log group. In the case of an S3 destination, it will create the S3 bucket.

If you want to customize any of the destination resources you can provide your own as part of the `destination`.

*CloudWatch Logs*

```python
# vpc: ec2.Vpc


log_group = logs.LogGroup(self, "MyCustomLogGroup")

role = iam.Role(self, "MyCustomRole",
    assumed_by=iam.ServicePrincipal("vpc-flow-logs.amazonaws.com")
)

ec2.FlowLog(self, "FlowLog",
    resource_type=ec2.FlowLogResourceType.from_vpc(vpc),
    destination=ec2.FlowLogDestination.to_cloud_watch_logs(log_group, role)
)
```

*S3*

```python
# vpc: ec2.Vpc


bucket = s3.Bucket(self, "MyCustomBucket")

ec2.FlowLog(self, "FlowLog",
    resource_type=ec2.FlowLogResourceType.from_vpc(vpc),
    destination=ec2.FlowLogDestination.to_s3(bucket)
)

ec2.FlowLog(self, "FlowLogWithKeyPrefix",
    resource_type=ec2.FlowLogResourceType.from_vpc(vpc),
    destination=ec2.FlowLogDestination.to_s3(bucket, "prefix/")
)
```

*Kinesis Data Firehose*

```python
import aws_cdk.aws_kinesisfirehose as firehose

# vpc: ec2.Vpc
# delivery_stream: firehose.CfnDeliveryStream


vpc.add_flow_log("FlowLogsKinesisDataFirehose",
    destination=ec2.FlowLogDestination.to_kinesis_data_firehose_destination(delivery_stream.attr_arn)
)
```

When the S3 destination is configured, AWS will automatically create an S3 bucket policy
that allows the service to write logs to the bucket. This makes it impossible to later update
that bucket policy. To have CDK create the bucket policy so that future updates can be made,
the `@aws-cdk/aws-s3:createDefaultLoggingPolicy` [feature flag](https://docs.aws.amazon.com/cdk/v2/guide/featureflags.html) can be used. This can be set
in the `cdk.json` file.

```json
{
  "context": {
    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true
  }
}
```

## User Data

User data enables you to run a script when your instances start up.  In order to configure these scripts you can add commands directly to the script
or you can use the UserData's convenience functions to aid in the creation of your script.

A user data could be configured to run a script found in an asset through the following:

```python
from aws_cdk.aws_s3_assets import Asset

# instance: ec2.Instance


asset = Asset(self, "Asset",
    path="./configure.sh"
)

local_path = instance.user_data.add_s3_download_command(
    bucket=asset.bucket,
    bucket_key=asset.s3_object_key,
    region="us-east-1"
)
instance.user_data.add_execute_file_command(
    file_path=local_path,
    arguments="--verbose -y"
)
asset.grant_read(instance.role)
```

### Persisting user data

By default, EC2 UserData is run once on only the first time that an instance is started. It is possible to make the
user data script run on every start of the instance.

When creating a Windows UserData you can use the `persist` option to set whether or not to add
`<persist>true</persist>` [to the user data script](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-windows-user-data.html#user-data-scripts). it can be used as follows:

```python
windows_user_data = ec2.UserData.for_windows(persist=True)
```

For a Linux instance, this can be accomplished by using a Multipart user data to configure cloud-config as detailed
in: https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/

### Multipart user data

In addition, to above the `MultipartUserData` can be used to change instance startup behavior. Multipart user data are composed
from separate parts forming archive. The most common parts are scripts executed during instance set-up. However, there are other
kinds, too.

The advantage of multipart archive is in flexibility when it's needed to add additional parts or to use specialized parts to
fine tune instance startup. Some services (like AWS Batch) support only `MultipartUserData`.

The parts can be executed at different moment of instance start-up and can serve a different purpose. This is controlled by `contentType` property.
For common scripts, `text/x-shellscript; charset="utf-8"` can be used as content type.

In order to create archive the `MultipartUserData` has to be instantiated. Than, user can add parts to multipart archive using `addPart`. The `MultipartBody` contains methods supporting creation of body parts.

If the very custom part is required, it can be created using `MultipartUserData.fromRawBody`, in this case full control over content type,
transfer encoding, and body properties is given to the user.

Below is an example for creating multipart user data with single body part responsible for installing `awscli` and configuring maximum size
of storage used by Docker containers:

```python
boot_hook_conf = ec2.UserData.for_linux()
boot_hook_conf.add_commands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker")

setup_commands = ec2.UserData.for_linux()
setup_commands.add_commands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup")

multipart_user_data = ec2.MultipartUserData()
# The docker has to be configured at early stage, so content type is overridden to boothook
multipart_user_data.add_part(ec2.MultipartBody.from_user_data(boot_hook_conf, "text/cloud-boothook; charset=\"us-ascii\""))
# Execute the rest of setup
multipart_user_data.add_part(ec2.MultipartBody.from_user_data(setup_commands))

ec2.LaunchTemplate(self, "",
    user_data=multipart_user_data,
    block_devices=[]
)
```

For more information see
[Specifying Multiple User Data Blocks Using a MIME Multi Part Archive](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#multi-part_user_data)

#### Using add*Command on MultipartUserData

To use the `add*Command` methods, that are inherited from the `UserData` interface, on `MultipartUserData` you must add a part
to the `MultipartUserData` and designate it as the receiver for these methods. This is accomplished by using the `addUserDataPart()`
method on `MultipartUserData` with the `makeDefault` argument set to `true`:

```python
multipart_user_data = ec2.MultipartUserData()
commands_user_data = ec2.UserData.for_linux()
multipart_user_data.add_user_data_part(commands_user_data, ec2.MultipartBody.SHELL_SCRIPT, True)

# Adding commands to the multipartUserData adds them to commandsUserData, and vice-versa.
multipart_user_data.add_commands("touch /root/multi.txt")
commands_user_data.add_commands("touch /root/userdata.txt")
```

When used on an EC2 instance, the above `multipartUserData` will create both `multi.txt` and `userdata.txt` in `/root`.

## Importing existing subnet

To import an existing Subnet, call `Subnet.fromSubnetAttributes()` or
`Subnet.fromSubnetId()`. Only if you supply the subnet's Availability Zone
and Route Table Ids when calling `Subnet.fromSubnetAttributes()` will you be
able to use the CDK features that use these values (such as selecting one
subnet per AZ).

Importing an existing subnet looks like this:

```python
# Supply all properties
subnet1 = ec2.Subnet.from_subnet_attributes(self, "SubnetFromAttributes",
    subnet_id="s-1234",
    availability_zone="pub-az-4465",
    route_table_id="rt-145"
)

# Supply only subnet id
subnet2 = ec2.Subnet.from_subnet_id(self, "SubnetFromId", "s-1234")
```

## Launch Templates

A Launch Template is a standardized template that contains the configuration information to launch an instance.
They can be used when launching instances on their own, through Amazon EC2 Auto Scaling, EC2 Fleet, and Spot Fleet.
Launch templates enable you to store launch parameters so that you do not have to specify them every time you launch
an instance. For information on Launch Templates please see the
[official documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html).

The following demonstrates how to create a launch template with an Amazon Machine Image, security group, and an instance profile.

```python
# vpc: ec2.Vpc


role = iam.Role(self, "Role",
    assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
)
instance_profile = iam.InstanceProfile(self, "InstanceProfile",
    role=role
)

template = ec2.LaunchTemplate(self, "LaunchTemplate",
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),
    security_group=ec2.SecurityGroup(self, "LaunchTemplateSG",
        vpc=vpc
    ),
    instance_profile=instance_profile
)
```

And the following demonstrates how to enable metadata options support.

```python
ec2.LaunchTemplate(self, "LaunchTemplate",
    http_endpoint=True,
    http_protocol_ipv6=True,
    http_put_response_hop_limit=1,
    http_tokens=ec2.LaunchTemplateHttpTokens.REQUIRED,
    instance_metadata_tags=True
)
```

And the following demonstrates how to add one or more security groups to launch template.

```python
# vpc: ec2.Vpc


sg1 = ec2.SecurityGroup(self, "sg1",
    vpc=vpc
)
sg2 = ec2.SecurityGroup(self, "sg2",
    vpc=vpc
)

launch_template = ec2.LaunchTemplate(self, "LaunchTemplate",
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),
    security_group=sg1
)

launch_template.add_security_group(sg2)
```

To use [AWS Systems Manager parameters instead of AMI IDs](https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html) in launch templates and resolve the AMI IDs at instance launch time:

```python
launch_template = ec2.LaunchTemplate(self, "LaunchTemplate",
    machine_image=ec2.MachineImage.resolve_ssm_parameter_at_launch("parameterName")
)
```

Please note this feature does not support Launch Configurations.

## Detailed Monitoring

The following demonstrates how to enable [Detailed Monitoring](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html) for an EC2 instance. Keep in mind that Detailed Monitoring results in [additional charges](http://aws.amazon.com/cloudwatch/pricing/).

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType


ec2.Instance(self, "Instance1",
    vpc=vpc,
    instance_type=instance_type,
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),
    detailed_monitoring=True
)
```

## Connecting to your instances using SSM Session Manager

SSM Session Manager makes it possible to connect to your instances from the
AWS Console, without preparing SSH keys.

To do so, you need to:

* Use an image with [SSM agent](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html) installed
  and configured. [Many images come with SSM Agent
  preinstalled](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html), otherwise you
  may need to manually put instructions to [install SSM
  Agent](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) into your
  instance's UserData or use EC2 Init).
* Create the instance with `ssmSessionPermissions: true`.

If these conditions are met, you can connect to the instance from the EC2 Console. Example:

```python
# vpc: ec2.Vpc
# instance_type: ec2.InstanceType


ec2.Instance(self, "Instance1",
    vpc=vpc,
    instance_type=instance_type,

    # Amazon Linux 2023 comes with SSM Agent by default
    machine_image=ec2.MachineImage.latest_amazon_linux2023(),

    # Turn on SSM
    ssm_session_permissions=True
)
```

## Managed Prefix Lists

Create and manage customer-managed prefix lists. If you don't specify anything in this construct, it will manage IPv4 addresses.

You can also create an empty Prefix List with only the maximum number of entries specified, as shown in the following code. If nothing is specified, maxEntries=1.

```python
ec2.PrefixList(self, "EmptyPrefixList",
    max_entries=100
)
```

`maxEntries` can also be omitted as follows. In this case `maxEntries: 2`, will be set.

```python
ec2.PrefixList(self, "PrefixList",
    entries=[ec2.CfnPrefixList.EntryProperty(cidr="10.0.0.1/32"), ec2.CfnPrefixList.EntryProperty(cidr="10.0.0.2/32", description="sample1")
    ]
)
```

For more information see [Work with customer-managed prefix lists](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-managed-prefix-lists.html)
'''
import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

from typeguard import check_type

from .._jsii import *

import constructs as _constructs_77d1e7e8
from .. import (
    AssetHashType as _AssetHashType_05b67f2d,
    BundlingOptions as _BundlingOptions_588cc936,
    CfnResource as _CfnResource_9df397a6,
    CfnTag as _CfnTag_f6864754,
    Duration as _Duration_4839e8c3,
    Expiration as _Expiration_059d47d0,
    IAspect as _IAspect_118c810a,
    IInspectable as _IInspectable_c2943556,
    IResolvable as _IResolvable_da3f097b,
    IResource as _IResource_c80c4260,
    ITaggable as _ITaggable_36806126,
    IgnoreMode as _IgnoreMode_655a98e8,
    RemovalPolicy as _RemovalPolicy_9f93c814,
    Resource as _Resource_45bc6135,
    ResourceProps as _ResourceProps_15a65b4e,
    SecretValue as _SecretValue_3dd0ddae,
    Size as _Size_7b441c34,
    Stack as _Stack_2866e57f,
    SymlinkFollowMode as _SymlinkFollowMode_047ec1f6,
    TagManager as _TagManager_0a598cb3,
    TreeInspector as _TreeInspector_488e0dd5,
)
from ..aws_cloudwatch import (
    Metric as _Metric_e396a4dc,
    MetricOptions as _MetricOptions_1788b62f,
    Unit as _Unit_61bc6f70,
)
from ..aws_iam import (
    ArnPrincipal as _ArnPrincipal_d31ca6bc,
    Grant as _Grant_a7ae64f8,
    IGrantable as _IGrantable_71c4f5de,
    IInstanceProfile as _IInstanceProfile_10d5ce2c,
    IPrincipal as _IPrincipal_539bb2fd,
    IRole as _IRole_235f5d8e,
    ISamlProvider as _ISamlProvider_63f03582,
    PolicyDocument as _PolicyDocument_3ac34393,
    PolicyStatement as _PolicyStatement_0fe33853,
)
from ..aws_kms import IKey as _IKey_5f11635f
from ..aws_logs import (
    ILogGroup as _ILogGroup_3c4fa718, ILogStream as _ILogStream_dcfca8c2
)
from ..aws_s3 import IBucket as _IBucket_42e086fd
from ..aws_s3_assets import (
    Asset as _Asset_ac2a7e61, AssetOptions as _AssetOptions_2aa69621
)
from ..aws_ssm import IStringParameter as _IStringParameter_f2b707f9


class AclCidr(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.AclCidr",
):
    '''Either an IPv4 or an IPv6 CIDR.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        acl_cidr = ec2.AclCidr.any_ipv4()
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="anyIpv4")
    @builtins.classmethod
    def any_ipv4(cls) -> "AclCidr":
        '''The CIDR containing all IPv4 addresses (i.e., 0.0.0.0/0).'''
        return typing.cast("AclCidr", jsii.sinvoke(cls, "anyIpv4", []))

    @jsii.member(jsii_name="anyIpv6")
    @builtins.classmethod
    def any_ipv6(cls) -> "AclCidr":
        '''The CIDR containing all IPv6 addresses (i.e., ::/0).'''
        return typing.cast("AclCidr", jsii.sinvoke(cls, "anyIpv6", []))

    @jsii.member(jsii_name="ipv4")
    @builtins.classmethod
    def ipv4(cls, ipv4_cidr: builtins.str) -> "AclCidr":
        '''An IP network range in CIDR notation (for example, 172.16.0.0/24).

        :param ipv4_cidr: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3ad2a5e4919c72fd0ec671df247f101b5b82e588009ce91566c9f396c19964d)
            check_type(argname="argument ipv4_cidr", value=ipv4_cidr, expected_type=type_hints["ipv4_cidr"])
        return typing.cast("AclCidr", jsii.sinvoke(cls, "ipv4", [ipv4_cidr]))

    @jsii.member(jsii_name="ipv6")
    @builtins.classmethod
    def ipv6(cls, ipv6_cidr: builtins.str) -> "AclCidr":
        '''An IPv6 network range in CIDR notation (for example, 2001:db8::/48).

        :param ipv6_cidr: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab6b9e0c88e64ab22e19f5a242a9ffd751298689bdc4a3606320998b2b7e339d)
            check_type(argname="argument ipv6_cidr", value=ipv6_cidr, expected_type=type_hints["ipv6_cidr"])
        return typing.cast("AclCidr", jsii.sinvoke(cls, "ipv6", [ipv6_cidr]))

    @jsii.member(jsii_name="toCidrConfig")
    @abc.abstractmethod
    def to_cidr_config(self) -> "AclCidrConfig":
        ...


class _AclCidrProxy(AclCidr):
    @jsii.member(jsii_name="toCidrConfig")
    def to_cidr_config(self) -> "AclCidrConfig":
        return typing.cast("AclCidrConfig", jsii.invoke(self, "toCidrConfig", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, AclCidr).__jsii_proxy_class__ = lambda : _AclCidrProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AclCidrConfig",
    jsii_struct_bases=[],
    name_mapping={"cidr_block": "cidrBlock", "ipv6_cidr_block": "ipv6CidrBlock"},
)
class AclCidrConfig:
    def __init__(
        self,
        *,
        cidr_block: typing.Optional[builtins.str] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Acl Configuration for CIDR.

        :param cidr_block: Ipv4 CIDR.
        :param ipv6_cidr_block: Ipv6 CIDR.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            acl_cidr_config = ec2.AclCidrConfig(
                cidr_block="cidrBlock",
                ipv6_cidr_block="ipv6CidrBlock"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a528042c63b989d3b0c11f7e3e2d7d5c63ef7f27ec1567d962210008609ac034)
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''Ipv4 CIDR.'''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''Ipv6 CIDR.'''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AclCidrConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AclIcmp",
    jsii_struct_bases=[],
    name_mapping={"code": "code", "type": "type"},
)
class AclIcmp:
    def __init__(
        self,
        *,
        code: typing.Optional[jsii.Number] = None,
        type: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties to create Icmp.

        :param code: The Internet Control Message Protocol (ICMP) code. You can use -1 to specify all ICMP codes for the given ICMP type. Requirement is conditional: Required if you specify 1 (ICMP) for the protocol parameter.
        :param type: The Internet Control Message Protocol (ICMP) type. You can use -1 to specify all ICMP types. Conditional requirement: Required if you specify 1 (ICMP) for the CreateNetworkAclEntry protocol parameter.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            acl_icmp = ec2.AclIcmp(
                code=123,
                type=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb17a149fd86e4bb35aa154a67bb9dd9d7ab9c56f326c8456deb5341e61d7f00)
            check_type(argname="argument code", value=code, expected_type=type_hints["code"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if code is not None:
            self._values["code"] = code
        if type is not None:
            self._values["type"] = type

    @builtins.property
    def code(self) -> typing.Optional[jsii.Number]:
        '''The Internet Control Message Protocol (ICMP) code.

        You can use -1 to specify all ICMP
        codes for the given ICMP type. Requirement is conditional: Required if you
        specify 1 (ICMP) for the protocol parameter.
        '''
        result = self._values.get("code")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def type(self) -> typing.Optional[jsii.Number]:
        '''The Internet Control Message Protocol (ICMP) type.

        You can use -1 to specify all ICMP types.
        Conditional requirement: Required if you specify 1 (ICMP) for the CreateNetworkAclEntry protocol parameter.
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AclIcmp(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AclPortRange",
    jsii_struct_bases=[],
    name_mapping={"from_": "from", "to": "to"},
)
class AclPortRange:
    def __init__(
        self,
        *,
        from_: typing.Optional[jsii.Number] = None,
        to: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties to create PortRange.

        :param from_: The first port in the range. Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.
        :param to: The last port in the range. Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            acl_port_range = ec2.AclPortRange(
                from=123,
                to=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c33fb537fef4ba8402530ec5630aee8c8410497a0863ede5f99ca517f82f449)
            check_type(argname="argument from_", value=from_, expected_type=type_hints["from_"])
            check_type(argname="argument to", value=to, expected_type=type_hints["to"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if from_ is not None:
            self._values["from_"] = from_
        if to is not None:
            self._values["to"] = to

    @builtins.property
    def from_(self) -> typing.Optional[jsii.Number]:
        '''The first port in the range.

        Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.
        '''
        result = self._values.get("from_")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def to(self) -> typing.Optional[jsii.Number]:
        '''The last port in the range.

        Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.
        '''
        result = self._values.get("to")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AclPortRange(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AclTraffic(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.AclTraffic",
):
    '''The traffic that is configured using a Network ACL entry.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        acl_traffic = ec2.AclTraffic.all_traffic()
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="allTraffic")
    @builtins.classmethod
    def all_traffic(cls) -> "AclTraffic":
        '''Apply the ACL entry to all traffic.'''
        return typing.cast("AclTraffic", jsii.sinvoke(cls, "allTraffic", []))

    @jsii.member(jsii_name="icmp")
    @builtins.classmethod
    def icmp(
        cls,
        *,
        code: typing.Optional[jsii.Number] = None,
        type: typing.Optional[jsii.Number] = None,
    ) -> "AclTraffic":
        '''Apply the ACL entry to ICMP traffic of given type and code.

        :param code: The Internet Control Message Protocol (ICMP) code. You can use -1 to specify all ICMP codes for the given ICMP type. Requirement is conditional: Required if you specify 1 (ICMP) for the protocol parameter.
        :param type: The Internet Control Message Protocol (ICMP) type. You can use -1 to specify all ICMP types. Conditional requirement: Required if you specify 1 (ICMP) for the CreateNetworkAclEntry protocol parameter.
        '''
        props = AclIcmp(code=code, type=type)

        return typing.cast("AclTraffic", jsii.sinvoke(cls, "icmp", [props]))

    @jsii.member(jsii_name="icmpv6")
    @builtins.classmethod
    def icmpv6(
        cls,
        *,
        code: typing.Optional[jsii.Number] = None,
        type: typing.Optional[jsii.Number] = None,
    ) -> "AclTraffic":
        '''Apply the ACL entry to ICMPv6 traffic of given type and code.

        Requires an IPv6 CIDR block.

        :param code: The Internet Control Message Protocol (ICMP) code. You can use -1 to specify all ICMP codes for the given ICMP type. Requirement is conditional: Required if you specify 1 (ICMP) for the protocol parameter.
        :param type: The Internet Control Message Protocol (ICMP) type. You can use -1 to specify all ICMP types. Conditional requirement: Required if you specify 1 (ICMP) for the CreateNetworkAclEntry protocol parameter.
        '''
        props = AclIcmp(code=code, type=type)

        return typing.cast("AclTraffic", jsii.sinvoke(cls, "icmpv6", [props]))

    @jsii.member(jsii_name="tcpPort")
    @builtins.classmethod
    def tcp_port(cls, port: jsii.Number) -> "AclTraffic":
        '''Apply the ACL entry to TCP traffic on a given port.

        :param port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e173d91f1c1835ccfdf6134dedc027e620c0f44039934fb8a281ef312e37d65)
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        return typing.cast("AclTraffic", jsii.sinvoke(cls, "tcpPort", [port]))

    @jsii.member(jsii_name="tcpPortRange")
    @builtins.classmethod
    def tcp_port_range(
        cls,
        start_port: jsii.Number,
        end_port: jsii.Number,
    ) -> "AclTraffic":
        '''Apply the ACL entry to TCP traffic on a given port range.

        :param start_port: -
        :param end_port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e335ec8df7c430d1e714bfe44c78e0cbeee9db3e25113497f4dd34eaf73bbf2)
            check_type(argname="argument start_port", value=start_port, expected_type=type_hints["start_port"])
            check_type(argname="argument end_port", value=end_port, expected_type=type_hints["end_port"])
        return typing.cast("AclTraffic", jsii.sinvoke(cls, "tcpPortRange", [start_port, end_port]))

    @jsii.member(jsii_name="udpPort")
    @builtins.classmethod
    def udp_port(cls, port: jsii.Number) -> "AclTraffic":
        '''Apply the ACL entry to UDP traffic on a given port.

        :param port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdfed3d1e83596c6d4a6c551d18618296a9bc3f9cb56f39949877474341e83d3)
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        return typing.cast("AclTraffic", jsii.sinvoke(cls, "udpPort", [port]))

    @jsii.member(jsii_name="udpPortRange")
    @builtins.classmethod
    def udp_port_range(
        cls,
        start_port: jsii.Number,
        end_port: jsii.Number,
    ) -> "AclTraffic":
        '''Apply the ACL entry to UDP traffic on a given port range.

        :param start_port: -
        :param end_port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c14e6bbd7559b33e3aa0635a4f52616c7f7431ee9711dcae11b1b5b3960e432d)
            check_type(argname="argument start_port", value=start_port, expected_type=type_hints["start_port"])
            check_type(argname="argument end_port", value=end_port, expected_type=type_hints["end_port"])
        return typing.cast("AclTraffic", jsii.sinvoke(cls, "udpPortRange", [start_port, end_port]))

    @jsii.member(jsii_name="toTrafficConfig")
    @abc.abstractmethod
    def to_traffic_config(self) -> "AclTrafficConfig":
        ...


class _AclTrafficProxy(AclTraffic):
    @jsii.member(jsii_name="toTrafficConfig")
    def to_traffic_config(self) -> "AclTrafficConfig":
        return typing.cast("AclTrafficConfig", jsii.invoke(self, "toTrafficConfig", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, AclTraffic).__jsii_proxy_class__ = lambda : _AclTrafficProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AclTrafficConfig",
    jsii_struct_bases=[],
    name_mapping={"protocol": "protocol", "icmp": "icmp", "port_range": "portRange"},
)
class AclTrafficConfig:
    def __init__(
        self,
        *,
        protocol: jsii.Number,
        icmp: typing.Optional[typing.Union[AclIcmp, typing.Dict[builtins.str, typing.Any]]] = None,
        port_range: typing.Optional[typing.Union[AclPortRange, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Acl Configuration for traffic.

        :param protocol: The protocol number. A value of "-1" means all protocols. If you specify "-1" or a protocol number other than "6" (TCP), "17" (UDP), or "1" (ICMP), traffic on all ports is allowed, regardless of any ports or ICMP types or codes that you specify. If you specify protocol "58" (ICMPv6) and specify an IPv4 CIDR block, traffic for all ICMP types and codes allowed, regardless of any that you specify. If you specify protocol "58" (ICMPv6) and specify an IPv6 CIDR block, you must specify an ICMP type and code. Default: 17
        :param icmp: The Internet Control Message Protocol (ICMP) code and type. Default: - Required if specifying 1 (ICMP) for the protocol parameter.
        :param port_range: The range of port numbers for the UDP/TCP protocol. Default: - Required if specifying 6 (TCP) or 17 (UDP) for the protocol parameter

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            acl_traffic_config = ec2.AclTrafficConfig(
                protocol=123,
            
                # the properties below are optional
                icmp=ec2.AclIcmp(
                    code=123,
                    type=123
                ),
                port_range=ec2.AclPortRange(
                    from=123,
                    to=123
                )
            )
        '''
        if isinstance(icmp, dict):
            icmp = AclIcmp(**icmp)
        if isinstance(port_range, dict):
            port_range = AclPortRange(**port_range)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d163c256d269f1d2f5078983924b9ad072aef3816da73da84929680d06b8d0bb)
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument icmp", value=icmp, expected_type=type_hints["icmp"])
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "protocol": protocol,
        }
        if icmp is not None:
            self._values["icmp"] = icmp
        if port_range is not None:
            self._values["port_range"] = port_range

    @builtins.property
    def protocol(self) -> jsii.Number:
        '''The protocol number.

        A value of "-1" means all protocols.

        If you specify "-1" or a protocol number other than "6" (TCP), "17" (UDP),
        or "1" (ICMP), traffic on all ports is allowed, regardless of any ports or
        ICMP types or codes that you specify.

        If you specify protocol "58" (ICMPv6) and specify an IPv4 CIDR
        block, traffic for all ICMP types and codes allowed, regardless of any that
        you specify. If you specify protocol "58" (ICMPv6) and specify an IPv6 CIDR
        block, you must specify an ICMP type and code.

        :default: 17
        '''
        result = self._values.get("protocol")
        assert result is not None, "Required property 'protocol' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def icmp(self) -> typing.Optional[AclIcmp]:
        '''The Internet Control Message Protocol (ICMP) code and type.

        :default: - Required if specifying 1 (ICMP) for the protocol parameter.
        '''
        result = self._values.get("icmp")
        return typing.cast(typing.Optional[AclIcmp], result)

    @builtins.property
    def port_range(self) -> typing.Optional[AclPortRange]:
        '''The range of port numbers for the UDP/TCP protocol.

        :default: - Required if specifying 6 (TCP) or 17 (UDP) for the protocol parameter
        '''
        result = self._values.get("port_range")
        return typing.cast(typing.Optional[AclPortRange], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AclTrafficConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.Action")
class Action(enum.Enum):
    '''What action to apply to traffic matching the ACL.'''

    ALLOW = "ALLOW"
    '''Allow the traffic.'''
    DENY = "DENY"
    '''Deny the traffic.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AddRouteOptions",
    jsii_struct_bases=[],
    name_mapping={
        "router_id": "routerId",
        "router_type": "routerType",
        "destination_cidr_block": "destinationCidrBlock",
        "destination_ipv6_cidr_block": "destinationIpv6CidrBlock",
        "enables_internet_connectivity": "enablesInternetConnectivity",
    },
)
class AddRouteOptions:
    def __init__(
        self,
        *,
        router_id: builtins.str,
        router_type: "RouterType",
        destination_cidr_block: typing.Optional[builtins.str] = None,
        destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
        enables_internet_connectivity: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Options for adding a new route to a subnet.

        :param router_id: The ID of the router. Can be an instance ID, gateway ID, etc, depending on the router type.
        :param router_type: What type of router to route this traffic to.
        :param destination_cidr_block: IPv4 range this route applies to. Default: '0.0.0.0/0'
        :param destination_ipv6_cidr_block: IPv6 range this route applies to. Default: - Uses IPv6
        :param enables_internet_connectivity: Whether this route will enable internet connectivity. If true, this route will be added before any AWS resources that depend on internet connectivity in the VPC will be created. Default: false

        :exampleMetadata: infused

        Example::

            vpc = ec2.Vpc(self, "VPC",
                subnet_configuration=[ec2.SubnetConfiguration(
                    subnet_type=ec2.SubnetType.PUBLIC,
                    name="Public"
                ), ec2.SubnetConfiguration(
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
                    name="Isolated"
                )]
            )
            
            (vpc.isolated_subnets[0]).add_route("StaticRoute",
                router_id=vpc.internet_gateway_id,
                router_type=ec2.RouterType.GATEWAY,
                destination_cidr_block="8.8.8.8/32"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f59a164a1424d8008d54093d179bfdbc68c5da0cf45fe708c6f2aa4ec7240d43)
            check_type(argname="argument router_id", value=router_id, expected_type=type_hints["router_id"])
            check_type(argname="argument router_type", value=router_type, expected_type=type_hints["router_type"])
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument destination_ipv6_cidr_block", value=destination_ipv6_cidr_block, expected_type=type_hints["destination_ipv6_cidr_block"])
            check_type(argname="argument enables_internet_connectivity", value=enables_internet_connectivity, expected_type=type_hints["enables_internet_connectivity"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "router_id": router_id,
            "router_type": router_type,
        }
        if destination_cidr_block is not None:
            self._values["destination_cidr_block"] = destination_cidr_block
        if destination_ipv6_cidr_block is not None:
            self._values["destination_ipv6_cidr_block"] = destination_ipv6_cidr_block
        if enables_internet_connectivity is not None:
            self._values["enables_internet_connectivity"] = enables_internet_connectivity

    @builtins.property
    def router_id(self) -> builtins.str:
        '''The ID of the router.

        Can be an instance ID, gateway ID, etc, depending on the router type.
        '''
        result = self._values.get("router_id")
        assert result is not None, "Required property 'router_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def router_type(self) -> "RouterType":
        '''What type of router to route this traffic to.'''
        result = self._values.get("router_type")
        assert result is not None, "Required property 'router_type' is missing"
        return typing.cast("RouterType", result)

    @builtins.property
    def destination_cidr_block(self) -> typing.Optional[builtins.str]:
        '''IPv4 range this route applies to.

        :default: '0.0.0.0/0'
        '''
        result = self._values.get("destination_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''IPv6 range this route applies to.

        :default: - Uses IPv6
        '''
        result = self._values.get("destination_ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enables_internet_connectivity(self) -> typing.Optional[builtins.bool]:
        '''Whether this route will enable internet connectivity.

        If true, this route will be added before any AWS resources that depend
        on internet connectivity in the VPC will be created.

        :default: false
        '''
        result = self._values.get("enables_internet_connectivity")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AddRouteOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AddressFamily")
class AddressFamily(enum.Enum):
    '''The IP address type.'''

    IP_V4 = "IP_V4"
    IP_V6 = "IP_V6"


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AllocateCidrRequest",
    jsii_struct_bases=[],
    name_mapping={"requested_subnets": "requestedSubnets", "vpc_cidr": "vpcCidr"},
)
class AllocateCidrRequest:
    def __init__(
        self,
        *,
        requested_subnets: typing.Sequence[typing.Union["RequestedSubnet", typing.Dict[builtins.str, typing.Any]]],
        vpc_cidr: builtins.str,
    ) -> None:
        '''Request for subnets CIDR to be allocated for a Vpc.

        :param requested_subnets: The Subnets to be allocated.
        :param vpc_cidr: The IPv4 CIDR block for this Vpc.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            allocate_cidr_request = ec2.AllocateCidrRequest(
                requested_subnets=[ec2.RequestedSubnet(
                    availability_zone="availabilityZone",
                    configuration=ec2.SubnetConfiguration(
                        name="name",
                        subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
            
                        # the properties below are optional
                        cidr_mask=123,
                        ipv6_assign_address_on_creation=False,
                        map_public_ip_on_launch=False,
                        reserved=False
                    ),
                    subnet_construct_id="subnetConstructId"
                )],
                vpc_cidr="vpcCidr"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1df4b2c29495f98d544593b7df7715ec829f51c17796f9e361e366395a4a9b0a)
            check_type(argname="argument requested_subnets", value=requested_subnets, expected_type=type_hints["requested_subnets"])
            check_type(argname="argument vpc_cidr", value=vpc_cidr, expected_type=type_hints["vpc_cidr"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "requested_subnets": requested_subnets,
            "vpc_cidr": vpc_cidr,
        }

    @builtins.property
    def requested_subnets(self) -> typing.List["RequestedSubnet"]:
        '''The Subnets to be allocated.'''
        result = self._values.get("requested_subnets")
        assert result is not None, "Required property 'requested_subnets' is missing"
        return typing.cast(typing.List["RequestedSubnet"], result)

    @builtins.property
    def vpc_cidr(self) -> builtins.str:
        '''The IPv4 CIDR block for this Vpc.'''
        result = self._values.get("vpc_cidr")
        assert result is not None, "Required property 'vpc_cidr' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AllocateCidrRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AllocateIpv6CidrRequest",
    jsii_struct_bases=[],
    name_mapping={"allocated_subnets": "allocatedSubnets", "ipv6_cidrs": "ipv6Cidrs"},
)
class AllocateIpv6CidrRequest:
    def __init__(
        self,
        *,
        allocated_subnets: typing.Sequence[typing.Union["AllocatedSubnet", typing.Dict[builtins.str, typing.Any]]],
        ipv6_cidrs: typing.Sequence[builtins.str],
    ) -> None:
        '''Request for subnet IPv6 CIDRs to be allocated for a VPC.

        :param allocated_subnets: List of subnets allocated with IPv4 CIDRs.
        :param ipv6_cidrs: The IPv6 CIDRs to be allocated to the subnets.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            allocate_ipv6_cidr_request = ec2.AllocateIpv6CidrRequest(
                allocated_subnets=[ec2.AllocatedSubnet(
                    cidr="cidr",
            
                    # the properties below are optional
                    ipv6_cidr="ipv6Cidr"
                )],
                ipv6_cidrs=["ipv6Cidrs"]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d2d15673b9e53df657dc88df46f1098eea51256e5f4addb1db32dc0e2690f00)
            check_type(argname="argument allocated_subnets", value=allocated_subnets, expected_type=type_hints["allocated_subnets"])
            check_type(argname="argument ipv6_cidrs", value=ipv6_cidrs, expected_type=type_hints["ipv6_cidrs"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "allocated_subnets": allocated_subnets,
            "ipv6_cidrs": ipv6_cidrs,
        }

    @builtins.property
    def allocated_subnets(self) -> typing.List["AllocatedSubnet"]:
        '''List of subnets allocated with IPv4 CIDRs.'''
        result = self._values.get("allocated_subnets")
        assert result is not None, "Required property 'allocated_subnets' is missing"
        return typing.cast(typing.List["AllocatedSubnet"], result)

    @builtins.property
    def ipv6_cidrs(self) -> typing.List[builtins.str]:
        '''The IPv6 CIDRs to be allocated to the subnets.'''
        result = self._values.get("ipv6_cidrs")
        assert result is not None, "Required property 'ipv6_cidrs' is missing"
        return typing.cast(typing.List[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AllocateIpv6CidrRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AllocateVpcIpv6CidrRequest",
    jsii_struct_bases=[],
    name_mapping={"scope": "scope", "vpc_id": "vpcId"},
)
class AllocateVpcIpv6CidrRequest:
    def __init__(
        self,
        *,
        scope: _constructs_77d1e7e8.Construct,
        vpc_id: builtins.str,
    ) -> None:
        '''Request for allocation of the VPC IPv6 CIDR.

        :param scope: The VPC construct to attach to.
        :param vpc_id: The id of the VPC.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            import constructs as constructs
            
            # construct: constructs.Construct
            
            allocate_vpc_ipv6_cidr_request = ec2.AllocateVpcIpv6CidrRequest(
                scope=construct,
                vpc_id="vpcId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__201ab4d786fad817892547309e43b9b3ecac389ee3325f1ab6705b11dbd09c0c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "scope": scope,
            "vpc_id": vpc_id,
        }

    @builtins.property
    def scope(self) -> _constructs_77d1e7e8.Construct:
        '''The VPC construct to attach to.'''
        result = self._values.get("scope")
        assert result is not None, "Required property 'scope' is missing"
        return typing.cast(_constructs_77d1e7e8.Construct, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The id of the VPC.'''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AllocateVpcIpv6CidrRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AllocatedSubnet",
    jsii_struct_bases=[],
    name_mapping={"cidr": "cidr", "ipv6_cidr": "ipv6Cidr"},
)
class AllocatedSubnet:
    def __init__(
        self,
        *,
        cidr: builtins.str,
        ipv6_cidr: typing.Optional[builtins.str] = None,
    ) -> None:
        '''CIDR Allocated Subnet.

        :param cidr: IPv4 CIDR Allocations for a Subnet. Note this is specific to the IPv4 CIDR.
        :param ipv6_cidr: IPv6 CIDR Allocations for a Subnet. Note this is specific to the IPv6 CIDR. Default: - no IPV6 CIDR

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            allocated_subnet = ec2.AllocatedSubnet(
                cidr="cidr",
            
                # the properties below are optional
                ipv6_cidr="ipv6Cidr"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cca8efe6fa73141fbec2a2cf91f8f6bf2e0f69d49252bd2d45b21fcb2dce3566)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument ipv6_cidr", value=ipv6_cidr, expected_type=type_hints["ipv6_cidr"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
        }
        if ipv6_cidr is not None:
            self._values["ipv6_cidr"] = ipv6_cidr

    @builtins.property
    def cidr(self) -> builtins.str:
        '''IPv4 CIDR Allocations for a Subnet.

        Note this is specific to the IPv4 CIDR.
        '''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ipv6_cidr(self) -> typing.Optional[builtins.str]:
        '''IPv6 CIDR Allocations for a Subnet.

        Note this is specific to the IPv6 CIDR.

        :default: - no IPV6 CIDR
        '''
        result = self._values.get("ipv6_cidr")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AllocatedSubnet(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AmazonLinux2022Kernel(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2022Kernel",
):
    '''Amazon Linux 2022 kernel versions.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        amazon_linux2022_kernel = ec2.AmazonLinux2022Kernel.CDK_LATEST
    '''

    def __init__(self, version: builtins.str) -> None:
        '''
        :param version: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67731f51c6dad8d404e1a6ed177e5a2605da4ce360058d786cf253f72d1aee3d)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        jsii.create(self.__class__, self, [version])

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''Generate a string representation of the kernel.'''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CDK_LATEST")
    def CDK_LATEST(cls) -> "AmazonLinux2022Kernel":
        '''The latest kernel version currently available in a published AMI.

        When a new kernel version is available for an al2022 AMI this will be
        updated to contain the latest kernel version and will cause your instances
        to be replaced. Do not store stateful information on the instance if you are
        using this version.
        '''
        return typing.cast("AmazonLinux2022Kernel", jsii.sget(cls, "CDK_LATEST"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT")
    def DEFAULT(cls) -> "AmazonLinux2022Kernel":
        '''The default kernel version for Amazon Linux 2022 is 5.15 and the SSM parameter does not include it in the name (i.e. /aws/service/ami-amazon-linux-latest/amzn2022-ami-kernel-default-x86_64).'''
        return typing.cast("AmazonLinux2022Kernel", jsii.sget(cls, "DEFAULT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KERNEL_5_15")
    def KERNEL_5_15(cls) -> "AmazonLinux2022Kernel":
        '''Kernel version 5.15.'''
        return typing.cast("AmazonLinux2022Kernel", jsii.sget(cls, "KERNEL_5_15"))


class AmazonLinux2023Kernel(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2023Kernel",
):
    '''Amazon Linux 2023 kernel versions.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        ec2.Instance(self, "LatestAl2023",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
            # context cache is turned on by default
            machine_image=ec2.AmazonLinux2023ImageSsmParameter(
                kernel=ec2.AmazonLinux2023Kernel.KERNEL_6_1
            )
        )
    '''

    def __init__(self, version: builtins.str) -> None:
        '''
        :param version: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ab727190b8ad0e28c2d1ddc702af61630c845ff5aedd9578b75429a06aba8f5)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        jsii.create(self.__class__, self, [version])

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''Generate a string representation of the kernel.'''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CDK_LATEST")
    def CDK_LATEST(cls) -> "AmazonLinux2023Kernel":
        '''The latest kernel version currently available in a published AMI.

        When a new kernel version is available for an al2023 AMI this will be
        updated to contain the latest kernel version and will cause your instances
        to be replaced. Do not store stateful information on the instance if you are
        using this version.
        '''
        return typing.cast("AmazonLinux2023Kernel", jsii.sget(cls, "CDK_LATEST"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT")
    def DEFAULT(cls) -> "AmazonLinux2023Kernel":
        '''The default kernel version for Amazon Linux 2023 is 6.1 and the SSM parameter does not include it in the name (i.e. /aws/service/ami-amazon-linux-latest/amzn2023-ami-kernel-default-x86_64).'''
        return typing.cast("AmazonLinux2023Kernel", jsii.sget(cls, "DEFAULT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KERNEL_6_1")
    def KERNEL_6_1(cls) -> "AmazonLinux2023Kernel":
        '''Kernel version 6.1.'''
        return typing.cast("AmazonLinux2023Kernel", jsii.sget(cls, "KERNEL_6_1"))


class AmazonLinux2Kernel(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2Kernel",
):
    '''Amazon Linux 2 kernel versions.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        # Amazon Linux 2
        ec2.Instance(self, "Instance2",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2()
        )
        
        # Amazon Linux 2 with kernel 5.x
        ec2.Instance(self, "Instance3",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2(
                kernel=ec2.AmazonLinux2Kernel.KERNEL_5_10
            )
        )
        
        # Amazon Linux 2023
        ec2.Instance(self, "Instance4",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023()
        )
        
        # Graviton 3 Processor
        ec2.Instance(self, "Instance5",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
            machine_image=ec2.MachineImage.latest_amazon_linux2023(
                cpu_type=ec2.AmazonLinuxCpuType.ARM_64
            )
        )
    '''

    def __init__(self, version: builtins.str) -> None:
        '''
        :param version: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d9d80aebc17990a8f3419f9444ec1fdd3e5bc1c150c3db0d42eda409806c7a8)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        jsii.create(self.__class__, self, [version])

    @jsii.member(jsii_name="toString")
    def to_string(self) -> typing.Optional[builtins.str]:
        '''Generate a string representation of the kernel.'''
        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "toString", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CDK_LATEST")
    def CDK_LATEST(cls) -> "AmazonLinux2Kernel":
        '''The latest kernel version currently available in a published AMI.

        When a new kernel version is available for an amzn2 AMI this will be
        updated to contain the latest kernel version and will cause your instances
        to be replaced. Do not store stateful information on the instance if you are
        using this version.
        '''
        return typing.cast("AmazonLinux2Kernel", jsii.sget(cls, "CDK_LATEST"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT")
    def DEFAULT(cls) -> "AmazonLinux2Kernel":
        '''The default kernel version for Amazon Linux 2 is 4.14 and Linux 4.14.311-233.529.amzn2.x86_64 the SSM parameter does not include it in the name (i.e. /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2).'''
        return typing.cast("AmazonLinux2Kernel", jsii.sget(cls, "DEFAULT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KERNEL_5_10")
    def KERNEL_5_10(cls) -> "AmazonLinux2Kernel":
        '''Kernel version 5.10.'''
        return typing.cast("AmazonLinux2Kernel", jsii.sget(cls, "KERNEL_5_10"))


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxCpuType")
class AmazonLinuxCpuType(enum.Enum):
    '''CPU type.

    :exampleMetadata: lit=aws-ec2/test/example.images.lit.ts infused

    Example::

        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.MachineImage.latest_amazon_linux(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE,
            cpu_type=ec2.AmazonLinuxCpuType.X86_64
        )
        
        # Pick a Windows edition to use
        windows = ec2.MachineImage.latest_windows(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Read AMI id from SSM parameter store
        ssm = ec2.MachineImage.from_ssm_parameter("/my/ami", os=ec2.OperatingSystemType.LINUX)
        
        # Look up the most recent image matching a set of AMI filters.
        # In this case, look up the NAT instance AMI, by using a wildcard
        # in the 'name' field:
        nat_ami = ec2.MachineImage.lookup(
            name="amzn-ami-vpc-nat-*",
            owners=["amazon"]
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        linux = ec2.MachineImage.generic_linux({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
        
        # For other custom (Windows) images, instantiate a `GenericWindowsImage` with
        # a map giving the AMI to in for each region:
        generic_windows = ec2.MachineImage.generic_windows({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    ARM_64 = "ARM_64"
    '''arm64 CPU type.'''
    X86_64 = "X86_64"
    '''x86_64 CPU type.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxEdition")
class AmazonLinuxEdition(enum.Enum):
    '''Amazon Linux edition.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    STANDARD = "STANDARD"
    '''Standard edition.'''
    MINIMAL = "MINIMAL"
    '''Minimal edition.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxGeneration")
class AmazonLinuxGeneration(enum.Enum):
    '''What generation of Amazon Linux to use.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    AMAZON_LINUX = "AMAZON_LINUX"
    '''Amazon Linux.'''
    AMAZON_LINUX_2 = "AMAZON_LINUX_2"
    '''Amazon Linux 2.'''
    AMAZON_LINUX_2022 = "AMAZON_LINUX_2022"
    '''Amazon Linux 2022.'''
    AMAZON_LINUX_2023 = "AMAZON_LINUX_2023"
    '''Amazon Linux 2023.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageProps",
    jsii_struct_bases=[],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "cpu_type": "cpuType",
        "edition": "edition",
        "generation": "generation",
        "kernel": "kernel",
        "storage": "storage",
        "user_data": "userData",
        "virtualization": "virtualization",
    },
)
class AmazonLinuxImageProps:
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        generation: typing.Optional[AmazonLinuxGeneration] = None,
        kernel: typing.Optional["AmazonLinuxKernel"] = None,
        storage: typing.Optional["AmazonLinuxStorage"] = None,
        user_data: typing.Optional["UserData"] = None,
        virtualization: typing.Optional["AmazonLinuxVirt"] = None,
    ) -> None:
        '''Amazon Linux image properties.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param cpu_type: CPU Type. Default: X86_64
        :param edition: What edition of Amazon Linux to use. Default: Standard
        :param generation: What generation of Amazon Linux to use. Default: AmazonLinux
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param virtualization: Virtualization type. Default: HVM

        :exampleMetadata: infused

        Example::

            # vpc: ec2.IVpc
            
            lb = elb.LoadBalancer(self, "LB",
                vpc=vpc,
                internet_facing=True
            )
            
            # instance to add as the target for load balancer.
            instance = ec2.Instance(self, "targetInstance",
                vpc=vpc,
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO),
                machine_image=ec2.AmazonLinuxImage(generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2)
            )
            lb.add_target(elb.InstanceTarget(instance))
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd95a518c06563a07debc9bf1ca51713b747cf64bded6f7cc81a28680d7ea9fc)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
            check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
            check_type(argname="argument generation", value=generation, expected_type=type_hints["generation"])
            check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
            check_type(argname="argument storage", value=storage, expected_type=type_hints["storage"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument virtualization", value=virtualization, expected_type=type_hints["virtualization"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if cpu_type is not None:
            self._values["cpu_type"] = cpu_type
        if edition is not None:
            self._values["edition"] = edition
        if generation is not None:
            self._values["generation"] = generation
        if kernel is not None:
            self._values["kernel"] = kernel
        if storage is not None:
            self._values["storage"] = storage
        if user_data is not None:
            self._values["user_data"] = user_data
        if virtualization is not None:
            self._values["virtualization"] = virtualization

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
        '''CPU Type.

        :default: X86_64
        '''
        result = self._values.get("cpu_type")
        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)

    @builtins.property
    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
        '''What edition of Amazon Linux to use.

        :default: Standard
        '''
        result = self._values.get("edition")
        return typing.cast(typing.Optional[AmazonLinuxEdition], result)

    @builtins.property
    def generation(self) -> typing.Optional[AmazonLinuxGeneration]:
        '''What generation of Amazon Linux to use.

        :default: AmazonLinux
        '''
        result = self._values.get("generation")
        return typing.cast(typing.Optional[AmazonLinuxGeneration], result)

    @builtins.property
    def kernel(self) -> typing.Optional["AmazonLinuxKernel"]:
        '''What kernel version of Amazon Linux to use.

        :default: -
        '''
        result = self._values.get("kernel")
        return typing.cast(typing.Optional["AmazonLinuxKernel"], result)

    @builtins.property
    def storage(self) -> typing.Optional["AmazonLinuxStorage"]:
        '''What storage backed image to use.

        :default: GeneralPurpose
        '''
        result = self._values.get("storage")
        return typing.cast(typing.Optional["AmazonLinuxStorage"], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    @builtins.property
    def virtualization(self) -> typing.Optional["AmazonLinuxVirt"]:
        '''Virtualization type.

        :default: HVM
        '''
        result = self._values.get("virtualization")
        return typing.cast(typing.Optional["AmazonLinuxVirt"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinuxImageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseOptions",
    jsii_struct_bases=[],
    name_mapping={"cached_in_context": "cachedInContext", "user_data": "userData"},
)
class AmazonLinuxImageSsmParameterBaseOptions:
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> None:
        '''Base options for amazon linux ssm parameters.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            amazon_linux_image_ssm_parameter_base_options = ec2.AmazonLinuxImageSsmParameterBaseOptions(
                cached_in_context=False,
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963ee6333f)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinuxImageSsmParameterBaseOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseProps",
    jsii_struct_bases=[AmazonLinuxImageSsmParameterBaseOptions],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "user_data": "userData",
        "parameter_name": "parameterName",
    },
)
class AmazonLinuxImageSsmParameterBaseProps(AmazonLinuxImageSsmParameterBaseOptions):
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
        parameter_name: builtins.str,
    ) -> None:
        '''Base properties for an Amazon Linux SSM Parameter.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param parameter_name: The name of the SSM parameter that contains the AMI value.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            amazon_linux_image_ssm_parameter_base_props = ec2.AmazonLinuxImageSsmParameterBaseProps(
                parameter_name="parameterName",
            
                # the properties below are optional
                cached_in_context=False,
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0c7383f1)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "parameter_name": parameter_name,
        }
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    @builtins.property
    def parameter_name(self) -> builtins.str:
        '''The name of the SSM parameter that contains the AMI value.'''
        result = self._values.get("parameter_name")
        assert result is not None, "Required property 'parameter_name' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinuxImageSsmParameterBaseProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterCommonOptions",
    jsii_struct_bases=[AmazonLinuxImageSsmParameterBaseOptions],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "user_data": "userData",
        "cpu_type": "cpuType",
        "edition": "edition",
    },
)
class AmazonLinuxImageSsmParameterCommonOptions(
    AmazonLinuxImageSsmParameterBaseOptions,
):
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
    ) -> None:
        '''Common options across all generations.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            amazon_linux_image_ssm_parameter_common_options = ec2.AmazonLinuxImageSsmParameterCommonOptions(
                cached_in_context=False,
                cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
                edition=ec2.AmazonLinuxEdition.STANDARD,
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8fcdd01a6ab45c77447fba339b5a9358c3ab40c4833c1f86c68009a6a3bb1422)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
            check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data
        if cpu_type is not None:
            self._values["cpu_type"] = cpu_type
        if edition is not None:
            self._values["edition"] = edition

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    @builtins.property
    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
        '''CPU Type.

        :default: AmazonLinuxCpuType.X86_64
        '''
        result = self._values.get("cpu_type")
        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)

    @builtins.property
    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
        '''What edition of Amazon Linux to use.

        :default: AmazonLinuxEdition.Standard
        '''
        result = self._values.get("edition")
        return typing.cast(typing.Optional[AmazonLinuxEdition], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinuxImageSsmParameterCommonOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxKernel")
class AmazonLinuxKernel(enum.Enum):
    '''Amazon Linux Kernel.'''

    KERNEL5_X = "KERNEL5_X"
    '''Kernel version 5.10.'''
    KERNEL6_1 = "KERNEL6_1"
    '''Kernel version 6.1.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxStorage")
class AmazonLinuxStorage(enum.Enum):
    '''Available storage options for Amazon Linux images Only applies to Amazon Linux & Amazon Linux 2.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    EBS = "EBS"
    '''EBS-backed storage.'''
    S3 = "S3"
    '''S3-backed storage.'''
    GENERAL_PURPOSE = "GENERAL_PURPOSE"
    '''General Purpose-based storage (recommended).'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxVirt")
class AmazonLinuxVirt(enum.Enum):
    '''Virtualization type for Amazon Linux.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    HVM = "HVM"
    '''HVM virtualization (recommended).'''
    PV = "PV"
    '''PV virtualization.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ApplyCloudFormationInitOptions",
    jsii_struct_bases=[],
    name_mapping={
        "config_sets": "configSets",
        "embed_fingerprint": "embedFingerprint",
        "ignore_failures": "ignoreFailures",
        "include_role": "includeRole",
        "include_url": "includeUrl",
        "print_log": "printLog",
        "timeout": "timeout",
    },
)
class ApplyCloudFormationInitOptions:
    def __init__(
        self,
        *,
        config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
        embed_fingerprint: typing.Optional[builtins.bool] = None,
        ignore_failures: typing.Optional[builtins.bool] = None,
        include_role: typing.Optional[builtins.bool] = None,
        include_url: typing.Optional[builtins.bool] = None,
        print_log: typing.Optional[builtins.bool] = None,
        timeout: typing.Optional[_Duration_4839e8c3] = None,
    ) -> None:
        '''Options for applying CloudFormation init to an instance or instance group.

        :param config_sets: ConfigSet to activate. Default: ['default']
        :param embed_fingerprint: Force instance replacement by embedding a config fingerprint. If ``true`` (the default), a hash of the config will be embedded into the UserData, so that if the config changes, the UserData changes. - If the EC2 instance is instance-store backed or ``userDataCausesReplacement`` is set, this will cause the instance to be replaced and the new configuration to be applied. - If the instance is EBS-backed and ``userDataCausesReplacement`` is not set, the change of UserData will make the instance restart but not be replaced, and the configuration will not be applied automatically. If ``false``, no hash will be embedded, and if the CloudFormation Init config changes nothing will happen to the running instance. If a config update introduces errors, you will not notice until after the CloudFormation deployment successfully finishes and the next instance fails to launch. Default: true
        :param ignore_failures: Don't fail the instance creation when cfn-init fails. You can use this to prevent CloudFormation from rolling back when instances fail to start up, to help in debugging. Default: false
        :param include_role: Include --role argument when running cfn-init and cfn-signal commands. This will be the IAM instance profile attached to the EC2 instance Default: false
        :param include_url: Include --url argument when running cfn-init and cfn-signal commands. This will be the cloudformation endpoint in the deployed region e.g. https://cloudformation.us-east-1.amazonaws.com Default: false
        :param print_log: Print the results of running cfn-init to the Instance System Log. By default, the output of running cfn-init is written to a log file on the instance. Set this to ``true`` to print it to the System Log (visible from the EC2 Console), ``false`` to not print it. (Be aware that the system log is refreshed at certain points in time of the instance life cycle, and successful execution may not always show up). Default: true
        :param timeout: Timeout waiting for the configuration to be applied. Default: Duration.minutes(5)

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            # instance_type: ec2.InstanceType
            # machine_image: ec2.IMachineImage
            
            
            ec2.Instance(self, "Instance",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=machine_image,
            
                # Showing the most complex setup, if you have simpler requirements
                # you can use `CloudFormationInit.fromElements()`.
                init=ec2.CloudFormationInit.from_config_sets(
                    config_sets={
                        # Applies the configs below in this order
                        "default": ["yumPreinstall", "config"]
                    },
                    configs={
                        "yum_preinstall": ec2.InitConfig([
                            # Install an Amazon Linux package using yum
                            ec2.InitPackage.yum("git")
                        ]),
                        "config": ec2.InitConfig([
                            # Create a JSON file from tokens (can also create other files)
                            ec2.InitFile.from_object("/etc/stack.json", {
                                "stack_id": Stack.of(self).stack_id,
                                "stack_name": Stack.of(self).stack_name,
                                "region": Stack.of(self).region
                            }),
            
                            # Create a group and user
                            ec2.InitGroup.from_name("my-group"),
                            ec2.InitUser.from_name("my-user"),
            
                            # Install an RPM from the internet
                            ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                        ])
                    }
                ),
                init_options=ec2.ApplyCloudFormationInitOptions(
                    # Optional, which configsets to activate (['default'] by default)
                    config_sets=["default"],
            
                    # Optional, how long the installation is expected to take (5 minutes by default)
                    timeout=Duration.minutes(30),
            
                    # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                    include_url=True,
            
                    # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                    include_role=True
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7f632381407c0e83d84ca5b16928a38d4d8f6de29513094b92a876e870ddb63)
            check_type(argname="argument config_sets", value=config_sets, expected_type=type_hints["config_sets"])
            check_type(argname="argument embed_fingerprint", value=embed_fingerprint, expected_type=type_hints["embed_fingerprint"])
            check_type(argname="argument ignore_failures", value=ignore_failures, expected_type=type_hints["ignore_failures"])
            check_type(argname="argument include_role", value=include_role, expected_type=type_hints["include_role"])
            check_type(argname="argument include_url", value=include_url, expected_type=type_hints["include_url"])
            check_type(argname="argument print_log", value=print_log, expected_type=type_hints["print_log"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if config_sets is not None:
            self._values["config_sets"] = config_sets
        if embed_fingerprint is not None:
            self._values["embed_fingerprint"] = embed_fingerprint
        if ignore_failures is not None:
            self._values["ignore_failures"] = ignore_failures
        if include_role is not None:
            self._values["include_role"] = include_role
        if include_url is not None:
            self._values["include_url"] = include_url
        if print_log is not None:
            self._values["print_log"] = print_log
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def config_sets(self) -> typing.Optional[typing.List[builtins.str]]:
        '''ConfigSet to activate.

        :default: ['default']
        '''
        result = self._values.get("config_sets")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def embed_fingerprint(self) -> typing.Optional[builtins.bool]:
        '''Force instance replacement by embedding a config fingerprint.

        If ``true`` (the default), a hash of the config will be embedded into the
        UserData, so that if the config changes, the UserData changes.

        - If the EC2 instance is instance-store backed or
          ``userDataCausesReplacement`` is set, this will cause the instance to be
          replaced and the new configuration to be applied.
        - If the instance is EBS-backed and ``userDataCausesReplacement`` is not
          set, the change of UserData will make the instance restart but not be
          replaced, and the configuration will not be applied automatically.

        If ``false``, no hash will be embedded, and if the CloudFormation Init
        config changes nothing will happen to the running instance. If a
        config update introduces errors, you will not notice until after the
        CloudFormation deployment successfully finishes and the next instance
        fails to launch.

        :default: true
        '''
        result = self._values.get("embed_fingerprint")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ignore_failures(self) -> typing.Optional[builtins.bool]:
        '''Don't fail the instance creation when cfn-init fails.

        You can use this to prevent CloudFormation from rolling back when
        instances fail to start up, to help in debugging.

        :default: false
        '''
        result = self._values.get("ignore_failures")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def include_role(self) -> typing.Optional[builtins.bool]:
        '''Include --role argument when running cfn-init and cfn-signal commands.

        This will be the IAM instance profile attached to the EC2 instance

        :default: false
        '''
        result = self._values.get("include_role")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def include_url(self) -> typing.Optional[builtins.bool]:
        '''Include --url argument when running cfn-init and cfn-signal commands.

        This will be the cloudformation endpoint in the deployed region
        e.g. https://cloudformation.us-east-1.amazonaws.com

        :default: false
        '''
        result = self._values.get("include_url")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def print_log(self) -> typing.Optional[builtins.bool]:
        '''Print the results of running cfn-init to the Instance System Log.

        By default, the output of running cfn-init is written to a log file
        on the instance. Set this to ``true`` to print it to the System Log
        (visible from the EC2 Console), ``false`` to not print it.

        (Be aware that the system log is refreshed at certain points in
        time of the instance life cycle, and successful execution may
        not always show up).

        :default: true
        '''
        result = self._values.get("print_log")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def timeout(self) -> typing.Optional[_Duration_4839e8c3]:
        '''Timeout waiting for the configuration to be applied.

        :default: Duration.minutes(5)
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional[_Duration_4839e8c3], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ApplyCloudFormationInitOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AttachInitOptions",
    jsii_struct_bases=[],
    name_mapping={
        "instance_role": "instanceRole",
        "platform": "platform",
        "user_data": "userData",
        "config_sets": "configSets",
        "embed_fingerprint": "embedFingerprint",
        "ignore_failures": "ignoreFailures",
        "include_role": "includeRole",
        "include_url": "includeUrl",
        "print_log": "printLog",
        "signal_resource": "signalResource",
    },
)
class AttachInitOptions:
    def __init__(
        self,
        *,
        instance_role: _IRole_235f5d8e,
        platform: "OperatingSystemType",
        user_data: "UserData",
        config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
        embed_fingerprint: typing.Optional[builtins.bool] = None,
        ignore_failures: typing.Optional[builtins.bool] = None,
        include_role: typing.Optional[builtins.bool] = None,
        include_url: typing.Optional[builtins.bool] = None,
        print_log: typing.Optional[builtins.bool] = None,
        signal_resource: typing.Optional[_CfnResource_9df397a6] = None,
    ) -> None:
        '''Options for attaching a CloudFormationInit to a resource.

        :param instance_role: Instance role of the consuming instance or fleet.
        :param platform: OS Platform the init config will be used for.
        :param user_data: UserData to add commands to.
        :param config_sets: ConfigSet to activate. Default: ['default']
        :param embed_fingerprint: Whether to embed a hash into the userData. If ``true`` (the default), a hash of the config will be embedded into the UserData, so that if the config changes, the UserData changes and the instance will be replaced. If ``false``, no such hash will be embedded, and if the CloudFormation Init config changes nothing will happen to the running instance. Default: true
        :param ignore_failures: Don't fail the instance creation when cfn-init fails. You can use this to prevent CloudFormation from rolling back when instances fail to start up, to help in debugging. Default: false
        :param include_role: Include --role argument when running cfn-init and cfn-signal commands. This will be the IAM instance profile attached to the EC2 instance Default: false
        :param include_url: Include --url argument when running cfn-init and cfn-signal commands. This will be the cloudformation endpoint in the deployed region e.g. https://cloudformation.us-east-1.amazonaws.com Default: false
        :param print_log: Print the results of running cfn-init to the Instance System Log. By default, the output of running cfn-init is written to a log file on the instance. Set this to ``true`` to print it to the System Log (visible from the EC2 Console), ``false`` to not print it. (Be aware that the system log is refreshed at certain points in time of the instance life cycle, and successful execution may not always show up). Default: true
        :param signal_resource: When provided, signals this resource instead of the attached resource. You can use this to support signaling LaunchTemplate while attaching AutoScalingGroup Default: - if this property is undefined cfn-signal signals the attached resource

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_iam as iam
            
            # cfn_resource: cdk.CfnResource
            # role: iam.Role
            # user_data: ec2.UserData
            
            attach_init_options = ec2.AttachInitOptions(
                instance_role=role,
                platform=ec2.OperatingSystemType.LINUX,
                user_data=user_data,
            
                # the properties below are optional
                config_sets=["configSets"],
                embed_fingerprint=False,
                ignore_failures=False,
                include_role=False,
                include_url=False,
                print_log=False,
                signal_resource=cfn_resource
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d40dbbec96cabb7e34633204b5a62ce85e126032034ff03db0d8c739abfb5a2d)
            check_type(argname="argument instance_role", value=instance_role, expected_type=type_hints["instance_role"])
            check_type(argname="argument platform", value=platform, expected_type=type_hints["platform"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument config_sets", value=config_sets, expected_type=type_hints["config_sets"])
            check_type(argname="argument embed_fingerprint", value=embed_fingerprint, expected_type=type_hints["embed_fingerprint"])
            check_type(argname="argument ignore_failures", value=ignore_failures, expected_type=type_hints["ignore_failures"])
            check_type(argname="argument include_role", value=include_role, expected_type=type_hints["include_role"])
            check_type(argname="argument include_url", value=include_url, expected_type=type_hints["include_url"])
            check_type(argname="argument print_log", value=print_log, expected_type=type_hints["print_log"])
            check_type(argname="argument signal_resource", value=signal_resource, expected_type=type_hints["signal_resource"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance_role": instance_role,
            "platform": platform,
            "user_data": user_data,
        }
        if config_sets is not None:
            self._values["config_sets"] = config_sets
        if embed_fingerprint is not None:
            self._values["embed_fingerprint"] = embed_fingerprint
        if ignore_failures is not None:
            self._values["ignore_failures"] = ignore_failures
        if include_role is not None:
            self._values["include_role"] = include_role
        if include_url is not None:
            self._values["include_url"] = include_url
        if print_log is not None:
            self._values["print_log"] = print_log
        if signal_resource is not None:
            self._values["signal_resource"] = signal_resource

    @builtins.property
    def instance_role(self) -> _IRole_235f5d8e:
        '''Instance role of the consuming instance or fleet.'''
        result = self._values.get("instance_role")
        assert result is not None, "Required property 'instance_role' is missing"
        return typing.cast(_IRole_235f5d8e, result)

    @builtins.property
    def platform(self) -> "OperatingSystemType":
        '''OS Platform the init config will be used for.'''
        result = self._values.get("platform")
        assert result is not None, "Required property 'platform' is missing"
        return typing.cast("OperatingSystemType", result)

    @builtins.property
    def user_data(self) -> "UserData":
        '''UserData to add commands to.'''
        result = self._values.get("user_data")
        assert result is not None, "Required property 'user_data' is missing"
        return typing.cast("UserData", result)

    @builtins.property
    def config_sets(self) -> typing.Optional[typing.List[builtins.str]]:
        '''ConfigSet to activate.

        :default: ['default']
        '''
        result = self._values.get("config_sets")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def embed_fingerprint(self) -> typing.Optional[builtins.bool]:
        '''Whether to embed a hash into the userData.

        If ``true`` (the default), a hash of the config will be embedded into the
        UserData, so that if the config changes, the UserData changes and
        the instance will be replaced.

        If ``false``, no such hash will be embedded, and if the CloudFormation Init
        config changes nothing will happen to the running instance.

        :default: true
        '''
        result = self._values.get("embed_fingerprint")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ignore_failures(self) -> typing.Optional[builtins.bool]:
        '''Don't fail the instance creation when cfn-init fails.

        You can use this to prevent CloudFormation from rolling back when
        instances fail to start up, to help in debugging.

        :default: false
        '''
        result = self._values.get("ignore_failures")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def include_role(self) -> typing.Optional[builtins.bool]:
        '''Include --role argument when running cfn-init and cfn-signal commands.

        This will be the IAM instance profile attached to the EC2 instance

        :default: false
        '''
        result = self._values.get("include_role")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def include_url(self) -> typing.Optional[builtins.bool]:
        '''Include --url argument when running cfn-init and cfn-signal commands.

        This will be the cloudformation endpoint in the deployed region
        e.g. https://cloudformation.us-east-1.amazonaws.com

        :default: false
        '''
        result = self._values.get("include_url")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def print_log(self) -> typing.Optional[builtins.bool]:
        '''Print the results of running cfn-init to the Instance System Log.

        By default, the output of running cfn-init is written to a log file
        on the instance. Set this to ``true`` to print it to the System Log
        (visible from the EC2 Console), ``false`` to not print it.

        (Be aware that the system log is refreshed at certain points in
        time of the instance life cycle, and successful execution may
        not always show up).

        :default: true
        '''
        result = self._values.get("print_log")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def signal_resource(self) -> typing.Optional[_CfnResource_9df397a6]:
        '''When provided, signals this resource instead of the attached resource.

        You can use this to support signaling LaunchTemplate while attaching AutoScalingGroup

        :default: - if this property is undefined cfn-signal signals the attached resource
        '''
        result = self._values.get("signal_resource")
        return typing.cast(typing.Optional[_CfnResource_9df397a6], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AttachInitOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AwsIpamProps",
    jsii_struct_bases=[],
    name_mapping={
        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
        "ipv4_netmask_length": "ipv4NetmaskLength",
        "default_subnet_ipv4_netmask_length": "defaultSubnetIpv4NetmaskLength",
    },
)
class AwsIpamProps:
    def __init__(
        self,
        *,
        ipv4_ipam_pool_id: builtins.str,
        ipv4_netmask_length: jsii.Number,
        default_subnet_ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Configuration for AwsIpam.

        :param ipv4_ipam_pool_id: Ipam Pool Id for ipv4 allocation.
        :param ipv4_netmask_length: Netmask length for Vpc.
        :param default_subnet_ipv4_netmask_length: Default length for Subnet ipv4 Network mask. Specify this option only if you do not specify all Subnets using SubnetConfiguration with a cidrMask Default: - Default ipv4 Subnet Mask for subnets in Vpc

        :exampleMetadata: infused

        Example::

            from aws_cdk.aws_ec2 import IpAddresses
            
            # pool: ec2.CfnIPAMPool
            
            
            ec2.Vpc(self, "TheVPC",
                ip_addresses=IpAddresses.aws_ipam_allocation(
                    ipv4_ipam_pool_id=pool.ref,
                    ipv4_netmask_length=18,
                    default_subnet_ipv4_netmask_length=24
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f03eeb114f6c99cb527203711f14fcc87021cebcc68936ea2dc38a933caa1694)
            check_type(argname="argument ipv4_ipam_pool_id", value=ipv4_ipam_pool_id, expected_type=type_hints["ipv4_ipam_pool_id"])
            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
            check_type(argname="argument default_subnet_ipv4_netmask_length", value=default_subnet_ipv4_netmask_length, expected_type=type_hints["default_subnet_ipv4_netmask_length"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipv4_ipam_pool_id": ipv4_ipam_pool_id,
            "ipv4_netmask_length": ipv4_netmask_length,
        }
        if default_subnet_ipv4_netmask_length is not None:
            self._values["default_subnet_ipv4_netmask_length"] = default_subnet_ipv4_netmask_length

    @builtins.property
    def ipv4_ipam_pool_id(self) -> builtins.str:
        '''Ipam Pool Id for ipv4 allocation.'''
        result = self._values.get("ipv4_ipam_pool_id")
        assert result is not None, "Required property 'ipv4_ipam_pool_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ipv4_netmask_length(self) -> jsii.Number:
        '''Netmask length for Vpc.'''
        result = self._values.get("ipv4_netmask_length")
        assert result is not None, "Required property 'ipv4_netmask_length' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def default_subnet_ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''Default length for Subnet ipv4 Network mask.

        Specify this option only if you do not specify all Subnets using SubnetConfiguration with a cidrMask

        :default: - Default ipv4 Subnet Mask for subnets in Vpc
        '''
        result = self._values.get("default_subnet_ipv4_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AwsIpamProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.BastionHostLinuxProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc": "vpc",
        "availability_zone": "availabilityZone",
        "block_devices": "blockDevices",
        "init": "init",
        "init_options": "initOptions",
        "instance_name": "instanceName",
        "instance_type": "instanceType",
        "machine_image": "machineImage",
        "require_imdsv2": "requireImdsv2",
        "security_group": "securityGroup",
        "subnet_selection": "subnetSelection",
    },
)
class BastionHostLinuxProps:
    def __init__(
        self,
        *,
        vpc: "IVpc",
        availability_zone: typing.Optional[builtins.str] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union["BlockDevice", typing.Dict[builtins.str, typing.Any]]]] = None,
        init: typing.Optional["CloudFormationInit"] = None,
        init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        instance_name: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional["InstanceType"] = None,
        machine_image: typing.Optional["IMachineImage"] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        security_group: typing.Optional["ISecurityGroup"] = None,
        subnet_selection: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Properties of the bastion host.

        :param vpc: VPC to launch the instance in.
        :param availability_zone: In which AZ to place the instance within the VPC. Default: - Random zone.
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param init: Apply the given CloudFormation Init configuration to the instance at startup. Default: - no CloudFormation init
        :param init_options: Use the given options for applying CloudFormation Init. Describes the configsets to use and the timeout to wait Default: - default options
        :param instance_name: The name of the instance. Default: 'BastionHost'
        :param instance_type: Type of instance to launch. Default: 't3.nano'
        :param machine_image: The machine image to use, assumed to have SSM Agent preinstalled. Default: - An Amazon Linux 2 image which is kept up-to-date automatically (the instance may be replaced on every deployment) and already has SSM Agent installed.
        :param require_imdsv2: Whether IMDSv2 should be required on this instance. Default: - false
        :param security_group: Security Group to assign to this instance. Default: - create new security group with no inbound and all outbound traffic allowed
        :param subnet_selection: Select the subnets to run the bastion host in. Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM. You have to allow port 22 manually by using the connections field Default: - private subnets of the supplied VPC

        :exampleMetadata: fixture=with-vpc infused

        Example::

            host = ec2.BastionHostLinux(self, "BastionHost",
                vpc=vpc,
                block_devices=[ec2.BlockDevice(
                    device_name="EBSBastionHost",
                    volume=ec2.BlockDeviceVolume.ebs(10,
                        encrypted=True
                    )
                )]
            )
        '''
        if isinstance(init_options, dict):
            init_options = ApplyCloudFormationInitOptions(**init_options)
        if isinstance(subnet_selection, dict):
            subnet_selection = SubnetSelection(**subnet_selection)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2647a77163fdd79c5b81f9523b8e35e195386f549d272d3474261e5251a24e52)
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument block_devices", value=block_devices, expected_type=type_hints["block_devices"])
            check_type(argname="argument init", value=init, expected_type=type_hints["init"])
            check_type(argname="argument init_options", value=init_options, expected_type=type_hints["init_options"])
            check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument machine_image", value=machine_image, expected_type=type_hints["machine_image"])
            check_type(argname="argument require_imdsv2", value=require_imdsv2, expected_type=type_hints["require_imdsv2"])
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc": vpc,
        }
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if block_devices is not None:
            self._values["block_devices"] = block_devices
        if init is not None:
            self._values["init"] = init
        if init_options is not None:
            self._values["init_options"] = init_options
        if instance_name is not None:
            self._values["instance_name"] = instance_name
        if instance_type is not None:
            self._values["instance_type"] = instance_type
        if machine_image is not None:
            self._values["machine_image"] = machine_image
        if require_imdsv2 is not None:
            self._values["require_imdsv2"] = require_imdsv2
        if security_group is not None:
            self._values["security_group"] = security_group
        if subnet_selection is not None:
            self._values["subnet_selection"] = subnet_selection

    @builtins.property
    def vpc(self) -> "IVpc":
        '''VPC to launch the instance in.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast("IVpc", result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''In which AZ to place the instance within the VPC.

        :default: - Random zone.
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def block_devices(self) -> typing.Optional[typing.List["BlockDevice"]]:
        '''Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.

        Each instance that is launched has an associated root device volume,
        either an Amazon EBS volume or an instance store volume.
        You can use block device mappings to specify additional EBS volumes or
        instance store volumes to attach to an instance when it is launched.

        :default: - Uses the block device mapping of the AMI

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html
        '''
        result = self._values.get("block_devices")
        return typing.cast(typing.Optional[typing.List["BlockDevice"]], result)

    @builtins.property
    def init(self) -> typing.Optional["CloudFormationInit"]:
        '''Apply the given CloudFormation Init configuration to the instance at startup.

        :default: - no CloudFormation init
        '''
        result = self._values.get("init")
        return typing.cast(typing.Optional["CloudFormationInit"], result)

    @builtins.property
    def init_options(self) -> typing.Optional[ApplyCloudFormationInitOptions]:
        '''Use the given options for applying CloudFormation Init.

        Describes the configsets to use and the timeout to wait

        :default: - default options
        '''
        result = self._values.get("init_options")
        return typing.cast(typing.Optional[ApplyCloudFormationInitOptions], result)

    @builtins.property
    def instance_name(self) -> typing.Optional[builtins.str]:
        '''The name of the instance.

        :default: 'BastionHost'
        '''
        result = self._values.get("instance_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_type(self) -> typing.Optional["InstanceType"]:
        '''Type of instance to launch.

        :default: 't3.nano'
        '''
        result = self._values.get("instance_type")
        return typing.cast(typing.Optional["InstanceType"], result)

    @builtins.property
    def machine_image(self) -> typing.Optional["IMachineImage"]:
        '''The machine image to use, assumed to have SSM Agent preinstalled.

        :default:

        - An Amazon Linux 2 image which is kept up-to-date automatically (the instance
        may be replaced on every deployment) and already has SSM Agent installed.
        '''
        result = self._values.get("machine_image")
        return typing.cast(typing.Optional["IMachineImage"], result)

    @builtins.property
    def require_imdsv2(self) -> typing.Optional[builtins.bool]:
        '''Whether IMDSv2 should be required on this instance.

        :default: - false
        '''
        result = self._values.get("require_imdsv2")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def security_group(self) -> typing.Optional["ISecurityGroup"]:
        '''Security Group to assign to this instance.

        :default: - create new security group with no inbound and all outbound traffic allowed
        '''
        result = self._values.get("security_group")
        return typing.cast(typing.Optional["ISecurityGroup"], result)

    @builtins.property
    def subnet_selection(self) -> typing.Optional["SubnetSelection"]:
        '''Select the subnets to run the bastion host in.

        Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM.
        You have to allow port 22 manually by using the connections field

        :default: - private subnets of the supplied VPC
        '''
        result = self._values.get("subnet_selection")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BastionHostLinuxProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.BlockDevice",
    jsii_struct_bases=[],
    name_mapping={
        "device_name": "deviceName",
        "volume": "volume",
        "mapping_enabled": "mappingEnabled",
    },
)
class BlockDevice:
    def __init__(
        self,
        *,
        device_name: builtins.str,
        volume: "BlockDeviceVolume",
        mapping_enabled: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Block device.

        :param device_name: The device name exposed to the EC2 instance. For example, a value like ``/dev/sdh``, ``xvdh``.
        :param volume: Defines the block device volume, to be either an Amazon EBS volume or an ephemeral instance store volume. For example, a value like ``BlockDeviceVolume.ebs(15)``, ``BlockDeviceVolume.ephemeral(0)``.
        :param mapping_enabled: If false, the device mapping will be suppressed. If set to false for the root device, the instance might fail the Amazon EC2 health check. Amazon EC2 Auto Scaling launches a replacement instance if the instance fails the health check. Default: true - device mapping is left untouched

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # block_device_volume: ec2.BlockDeviceVolume
            
            block_device = ec2.BlockDevice(
                device_name="deviceName",
                volume=block_device_volume,
            
                # the properties below are optional
                mapping_enabled=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d6658aae654252e134d66f13fd022e06de0b6f39cf994c929751371e10c0774d)
            check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
            check_type(argname="argument volume", value=volume, expected_type=type_hints["volume"])
            check_type(argname="argument mapping_enabled", value=mapping_enabled, expected_type=type_hints["mapping_enabled"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "device_name": device_name,
            "volume": volume,
        }
        if mapping_enabled is not None:
            self._values["mapping_enabled"] = mapping_enabled

    @builtins.property
    def device_name(self) -> builtins.str:
        '''The device name exposed to the EC2 instance.

        For example, a value like ``/dev/sdh``, ``xvdh``.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/device_naming.html
        '''
        result = self._values.get("device_name")
        assert result is not None, "Required property 'device_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def volume(self) -> "BlockDeviceVolume":
        '''Defines the block device volume, to be either an Amazon EBS volume or an ephemeral instance store volume.

        For example, a value like ``BlockDeviceVolume.ebs(15)``, ``BlockDeviceVolume.ephemeral(0)``.
        '''
        result = self._values.get("volume")
        assert result is not None, "Required property 'volume' is missing"
        return typing.cast("BlockDeviceVolume", result)

    @builtins.property
    def mapping_enabled(self) -> typing.Optional[builtins.bool]:
        '''If false, the device mapping will be suppressed.

        If set to false for the root device, the instance might fail the Amazon EC2 health check.
        Amazon EC2 Auto Scaling launches a replacement instance if the instance fails the health check.

        :default: true - device mapping is left untouched
        '''
        result = self._values.get("mapping_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BlockDevice(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BlockDeviceVolume(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.BlockDeviceVolume",
):
    '''Describes a block device mapping for an EC2 instance or Auto Scaling group.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        # machine_image: ec2.IMachineImage
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=machine_image,
        
            # ...
        
            block_devices=[ec2.BlockDevice(
                device_name="/dev/sda1",
                volume=ec2.BlockDeviceVolume.ebs(50)
            ), ec2.BlockDevice(
                device_name="/dev/sdm",
                volume=ec2.BlockDeviceVolume.ebs(100)
            )
            ]
        )
    '''

    def __init__(
        self,
        ebs_device: typing.Optional[typing.Union["EbsDeviceProps", typing.Dict[builtins.str, typing.Any]]] = None,
        virtual_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param ebs_device: EBS device info.
        :param virtual_name: Virtual device name.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8805c499a7a0c5dd9580d5a1c8b85b4f543fea2c6e746e9d2815091e05d36c52)
            check_type(argname="argument ebs_device", value=ebs_device, expected_type=type_hints["ebs_device"])
            check_type(argname="argument virtual_name", value=virtual_name, expected_type=type_hints["virtual_name"])
        jsii.create(self.__class__, self, [ebs_device, virtual_name])

    @jsii.member(jsii_name="ebs")
    @builtins.classmethod
    def ebs(
        cls,
        volume_size: jsii.Number,
        *,
        encrypted: typing.Optional[builtins.bool] = None,
        kms_key: typing.Optional[_IKey_5f11635f] = None,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional["EbsDeviceVolumeType"] = None,
    ) -> "BlockDeviceVolume":
        '''Creates a new Elastic Block Storage device.

        :param volume_size: The volume size, in Gibibytes (GiB).
        :param encrypted: Specifies whether the EBS volume is encrypted. Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption Default: false
        :param kms_key: The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption. You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances. Default: - If encrypted is true, the default aws/ebs KMS key will be used.
        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e34634be08d573bd7d4eca032a2a66e619c889f2b51e62608777ae0db2639e6a)
            check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
        options = EbsDeviceOptions(
            encrypted=encrypted,
            kms_key=kms_key,
            delete_on_termination=delete_on_termination,
            iops=iops,
            volume_type=volume_type,
        )

        return typing.cast("BlockDeviceVolume", jsii.sinvoke(cls, "ebs", [volume_size, options]))

    @jsii.member(jsii_name="ebsFromSnapshot")
    @builtins.classmethod
    def ebs_from_snapshot(
        cls,
        snapshot_id: builtins.str,
        *,
        volume_size: typing.Optional[jsii.Number] = None,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional["EbsDeviceVolumeType"] = None,
    ) -> "BlockDeviceVolume":
        '''Creates a new Elastic Block Storage device from an existing snapshot.

        :param snapshot_id: The snapshot ID of the volume to use.
        :param volume_size: The volume size, in Gibibytes (GiB). If you specify volumeSize, it must be equal or greater than the size of the snapshot. Default: - The snapshot size
        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce9e60bc1da1c6f1d133c0cfaad0c5984d2f7a428c12f02640d8f31c6eab041e)
            check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
        options = EbsDeviceSnapshotOptions(
            volume_size=volume_size,
            delete_on_termination=delete_on_termination,
            iops=iops,
            volume_type=volume_type,
        )

        return typing.cast("BlockDeviceVolume", jsii.sinvoke(cls, "ebsFromSnapshot", [snapshot_id, options]))

    @jsii.member(jsii_name="ephemeral")
    @builtins.classmethod
    def ephemeral(cls, volume_index: jsii.Number) -> "BlockDeviceVolume":
        '''Creates a virtual, ephemeral device.

        The name will be in the form ephemeral{volumeIndex}.

        :param volume_index: the volume index. Must be equal or greater than 0
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3bf1e1313f470f70824bf7224f1fd91d59ad3cef90451484660764b691d8481)
            check_type(argname="argument volume_index", value=volume_index, expected_type=type_hints["volume_index"])
        return typing.cast("BlockDeviceVolume", jsii.sinvoke(cls, "ephemeral", [volume_index]))

    @builtins.property
    @jsii.member(jsii_name="ebsDevice")
    def ebs_device(self) -> typing.Optional["EbsDeviceProps"]:
        '''EBS device info.'''
        return typing.cast(typing.Optional["EbsDeviceProps"], jsii.get(self, "ebsDevice"))

    @builtins.property
    @jsii.member(jsii_name="virtualName")
    def virtual_name(self) -> typing.Optional[builtins.str]:
        '''Virtual device name.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "virtualName"))


@jsii.implements(_IInspectable_c2943556)
class CfnCapacityReservation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservation",
):
    '''Creates a new Capacity Reservation with the specified attributes.

    For more information, see `Capacity Reservations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html>`_ in the *Amazon EC2 User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html
    :cloudformationResource: AWS::EC2::CapacityReservation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_capacity_reservation = ec2.CfnCapacityReservation(self, "MyCfnCapacityReservation",
            availability_zone="availabilityZone",
            instance_count=123,
            instance_platform="instancePlatform",
            instance_type="instanceType",
        
            # the properties below are optional
            ebs_optimized=False,
            end_date="endDate",
            end_date_type="endDateType",
            ephemeral_storage=False,
            instance_match_criteria="instanceMatchCriteria",
            out_post_arn="outPostArn",
            placement_group_arn="placementGroupArn",
            tag_specifications=[ec2.CfnCapacityReservation.TagSpecificationProperty(
                resource_type="resourceType",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )],
            tenancy="tenancy"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        instance_count: jsii.Number,
        instance_platform: builtins.str,
        instance_type: builtins.str,
        ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        end_date: typing.Optional[builtins.str] = None,
        end_date_type: typing.Optional[builtins.str] = None,
        ephemeral_storage: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        instance_match_criteria: typing.Optional[builtins.str] = None,
        out_post_arn: typing.Optional[builtins.str] = None,
        placement_group_arn: typing.Optional[builtins.str] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityReservation.TagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param availability_zone: The Availability Zone in which to create the Capacity Reservation.
        :param instance_count: The number of instances for which to reserve capacity. Valid range: 1 - 1000
        :param instance_platform: The type of operating system for which to reserve capacity.
        :param instance_type: The instance type for which to reserve capacity. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .
        :param ebs_optimized: Indicates whether the Capacity Reservation supports EBS-optimized instances. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS- optimized instance.
        :param end_date: The date and time at which the Capacity Reservation expires. When a Capacity Reservation expires, the reserved capacity is released and you can no longer launch instances into it. The Capacity Reservation's state changes to ``expired`` when it reaches its end date and time. You must provide an ``EndDate`` value if ``EndDateType`` is ``limited`` . Omit ``EndDate`` if ``EndDateType`` is ``unlimited`` . If the ``EndDateType`` is ``limited`` , the Capacity Reservation is cancelled within an hour from the specified time. For example, if you specify 5/31/2019, 13:30:55, the Capacity Reservation is guaranteed to end between 13:30:55 and 14:30:55 on 5/31/2019.
        :param end_date_type: Indicates the way in which the Capacity Reservation ends. A Capacity Reservation can have one of the following end types: - ``unlimited`` - The Capacity Reservation remains active until you explicitly cancel it. Do not provide an ``EndDate`` if the ``EndDateType`` is ``unlimited`` . - ``limited`` - The Capacity Reservation expires automatically at a specified date and time. You must provide an ``EndDate`` value if the ``EndDateType`` value is ``limited`` .
        :param ephemeral_storage: *Deprecated.*.
        :param instance_match_criteria: Indicates the type of instance launches that the Capacity Reservation accepts. The options include:. - ``open`` - The Capacity Reservation automatically matches all instances that have matching attributes (instance type, platform, and Availability Zone). Instances that have matching attributes run in the Capacity Reservation automatically without specifying any additional parameters. - ``targeted`` - The Capacity Reservation only accepts instances that have matching attributes (instance type, platform, and Availability Zone), and explicitly target the Capacity Reservation. This ensures that only permitted instances can use the reserved capacity. Default: ``open``
        :param out_post_arn: The Amazon Resource Name (ARN) of the Outpost on which to create the Capacity Reservation.
        :param placement_group_arn: The Amazon Resource Name (ARN) of the cluster placement group in which to create the Capacity Reservation. For more information, see `Capacity Reservations for cluster placement groups <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-cpg.html>`_ in the *Amazon EC2 User Guide* .
        :param tag_specifications: The tags to apply to the Capacity Reservation during launch.
        :param tenancy: Indicates the tenancy of the Capacity Reservation. A Capacity Reservation can have one of the following tenancy settings:. - ``default`` - The Capacity Reservation is created on hardware that is shared with other AWS accounts . - ``dedicated`` - The Capacity Reservation is created on single-tenant hardware that is dedicated to a single AWS account .
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96fb3bc559aaa9df971e86ea7cdd3cdc3de550019a2d3bf247d3fb169b5e9f7e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnCapacityReservationProps(
            availability_zone=availability_zone,
            instance_count=instance_count,
            instance_platform=instance_platform,
            instance_type=instance_type,
            ebs_optimized=ebs_optimized,
            end_date=end_date,
            end_date_type=end_date_type,
            ephemeral_storage=ephemeral_storage,
            instance_match_criteria=instance_match_criteria,
            out_post_arn=out_post_arn,
            placement_group_arn=placement_group_arn,
            tag_specifications=tag_specifications,
            tenancy=tenancy,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ac561edf867860b2e6780f7d06fe916bfb499cbbdab9e47874e784f8ee13259f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b837e3858811127cec4a1a49ef5fbc9c4920b9ca228950a0e8797ab41d9a406)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAvailabilityZone")
    def attr_availability_zone(self) -> builtins.str:
        '''Returns the Availability Zone in which the capacity is reserved.

        For example: ``us-east-1a`` .

        :cloudformationAttribute: AvailabilityZone
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="attrAvailableInstanceCount")
    def attr_available_instance_count(self) -> jsii.Number:
        '''Returns the remaining capacity, which indicates the number of instances that can be launched in the Capacity Reservation.

        For example: ``9`` .

        :cloudformationAttribute: AvailableInstanceCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrAvailableInstanceCount"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the Capacity Reservation.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrInstanceType")
    def attr_instance_type(self) -> builtins.str:
        '''Returns the type of instance for which the capacity is reserved.

        For example: ``m4.large`` .

        :cloudformationAttribute: InstanceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrInstanceType"))

    @builtins.property
    @jsii.member(jsii_name="attrTenancy")
    def attr_tenancy(self) -> builtins.str:
        '''Returns the tenancy of the Capacity Reservation.

        For example: ``dedicated`` .

        :cloudformationAttribute: Tenancy
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTenancy"))

    @builtins.property
    @jsii.member(jsii_name="attrTotalInstanceCount")
    def attr_total_instance_count(self) -> jsii.Number:
        '''Returns the total number of instances for which the Capacity Reservation reserves capacity.

        For example: ``15`` .

        :cloudformationAttribute: TotalInstanceCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrTotalInstanceCount"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone in which to create the Capacity Reservation.'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @availability_zone.setter
    def availability_zone(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c78e4680a157e3466009de77e8aa625d8cf7fee8e6f0094ed98d312434e17d0f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZone", value)

    @builtins.property
    @jsii.member(jsii_name="instanceCount")
    def instance_count(self) -> jsii.Number:
        '''The number of instances for which to reserve capacity.'''
        return typing.cast(jsii.Number, jsii.get(self, "instanceCount"))

    @instance_count.setter
    def instance_count(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22b368a04915e99dd5744c69aee4e5f18ce694f374f86d57efdd11669b182094)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceCount", value)

    @builtins.property
    @jsii.member(jsii_name="instancePlatform")
    def instance_platform(self) -> builtins.str:
        '''The type of operating system for which to reserve capacity.'''
        return typing.cast(builtins.str, jsii.get(self, "instancePlatform"))

    @instance_platform.setter
    def instance_platform(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61255c59c261f39ea55478e744de40ef81c899601741a479966b55964910425d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instancePlatform", value)

    @builtins.property
    @jsii.member(jsii_name="instanceType")
    def instance_type(self) -> builtins.str:
        '''The instance type for which to reserve capacity.'''
        return typing.cast(builtins.str, jsii.get(self, "instanceType"))

    @instance_type.setter
    def instance_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__77123d0c19c0832f7509cd76b26aa9299b7596606999f89281b470a4f13db290)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceType", value)

    @builtins.property
    @jsii.member(jsii_name="ebsOptimized")
    def ebs_optimized(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the Capacity Reservation supports EBS-optimized instances.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "ebsOptimized"))

    @ebs_optimized.setter
    def ebs_optimized(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__678dbc8559016cf13cc067fc0b1a2efbca67b43c58a19ad6cb861f9f92eaffde)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ebsOptimized", value)

    @builtins.property
    @jsii.member(jsii_name="endDate")
    def end_date(self) -> typing.Optional[builtins.str]:
        '''The date and time at which the Capacity Reservation expires.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "endDate"))

    @end_date.setter
    def end_date(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4cb6531edd4f2f2d84580cab98baebb9524704a86fe4420ac1fedab59c3f11a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "endDate", value)

    @builtins.property
    @jsii.member(jsii_name="endDateType")
    def end_date_type(self) -> typing.Optional[builtins.str]:
        '''Indicates the way in which the Capacity Reservation ends.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "endDateType"))

    @end_date_type.setter
    def end_date_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ab7a3bc671d2cc1cbe9b8533b6cf3f81fbcdd7c629787d6fbcf162a2f7991b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "endDateType", value)

    @builtins.property
    @jsii.member(jsii_name="ephemeralStorage")
    def ephemeral_storage(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''*Deprecated.*.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "ephemeralStorage"))

    @ephemeral_storage.setter
    def ephemeral_storage(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e71563d063a54b01a1641ea15d2304c47a9442638bf103f23bb2279e72a805b0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ephemeralStorage", value)

    @builtins.property
    @jsii.member(jsii_name="instanceMatchCriteria")
    def instance_match_criteria(self) -> typing.Optional[builtins.str]:
        '''Indicates the type of instance launches that the Capacity Reservation accepts.

        The options include:.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceMatchCriteria"))

    @instance_match_criteria.setter
    def instance_match_criteria(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f474d13d66628cd099f8b6e63a960fb1e11e349a6e30dd4bcea58da40fde501a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceMatchCriteria", value)

    @builtins.property
    @jsii.member(jsii_name="outPostArn")
    def out_post_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost on which to create the Capacity Reservation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "outPostArn"))

    @out_post_arn.setter
    def out_post_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a8dbcf49c490eda04d32bf6b351f510a5d071b5754a19fa2c2b95c6ce0c22f0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "outPostArn", value)

    @builtins.property
    @jsii.member(jsii_name="placementGroupArn")
    def placement_group_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the cluster placement group in which to create the Capacity Reservation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "placementGroupArn"))

    @placement_group_arn.setter
    def placement_group_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__16fa52eb55faf78ebc17e0e8d27a241715110e3c4255fe91c5b59c36ac83d329)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "placementGroupArn", value)

    @builtins.property
    @jsii.member(jsii_name="tagSpecifications")
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservation.TagSpecificationProperty"]]]]:
        '''The tags to apply to the Capacity Reservation during launch.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservation.TagSpecificationProperty"]]]], jsii.get(self, "tagSpecifications"))

    @tag_specifications.setter
    def tag_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservation.TagSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2d4ed674b30189cbf7b11b79e68ea556b2b7c9921a4d61f7610b58d25fed8ca)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="tenancy")
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''Indicates the tenancy of the Capacity Reservation.

        A Capacity Reservation can have one of the following tenancy settings:.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tenancy"))

    @tenancy.setter
    def tenancy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__26e29c48a6cb47934fcf7b54e3d3eed16da0c88c8d717089ac043c03ebac0b5b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tenancy", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservation.TagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class TagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''An array of key-value pairs to apply to this resource.

            For more information, see `Tag <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html>`_ .

            :param resource_type: The type of resource to tag. Specify ``capacity-reservation`` .
            :param tags: The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservation-tagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                tag_specification_property = ec2.CfnCapacityReservation.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__578daf872c6424406c4ac67bfb16e1a373fb40f41078950b64a62c991d0be846)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource to tag.

            Specify ``capacity-reservation`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservation-tagspecification.html#cfn-ec2-capacityreservation-tagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservation-tagspecification.html#cfn-ec2-capacityreservation-tagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnCapacityReservationFleet(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservationFleet",
):
    '''Creates a new Capacity Reservation Fleet with the specified attributes.

    For more information, see `Capacity Reservation Fleets <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-fleets.html>`_ in the *Amazon EC2 User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html
    :cloudformationResource: AWS::EC2::CapacityReservationFleet
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_capacity_reservation_fleet = ec2.CfnCapacityReservationFleet(self, "MyCfnCapacityReservationFleet",
            allocation_strategy="allocationStrategy",
            end_date="endDate",
            instance_match_criteria="instanceMatchCriteria",
            instance_type_specifications=[ec2.CfnCapacityReservationFleet.InstanceTypeSpecificationProperty(
                availability_zone="availabilityZone",
                availability_zone_id="availabilityZoneId",
                ebs_optimized=False,
                instance_platform="instancePlatform",
                instance_type="instanceType",
                priority=123,
                weight=123
            )],
            no_remove_end_date=False,
            remove_end_date=False,
            tag_specifications=[ec2.CfnCapacityReservationFleet.TagSpecificationProperty(
                resource_type="resourceType",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )],
            tenancy="tenancy",
            total_target_capacity=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        allocation_strategy: typing.Optional[builtins.str] = None,
        end_date: typing.Optional[builtins.str] = None,
        instance_match_criteria: typing.Optional[builtins.str] = None,
        instance_type_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityReservationFleet.InstanceTypeSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        no_remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityReservationFleet.TagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
        total_target_capacity: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param allocation_strategy: The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use. Currently, only the ``prioritized`` allocation strategy is supported. For more information, see `Allocation strategy <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy>`_ in the Amazon EC2 User Guide. Valid values: ``prioritized``
        :param end_date: The date and time at which the Capacity Reservation Fleet expires. When the Capacity Reservation Fleet expires, its state changes to ``expired`` and all of the Capacity Reservations in the Fleet expire. The Capacity Reservation Fleet expires within an hour after the specified time. For example, if you specify ``5/31/2019`` , ``13:30:55`` , the Capacity Reservation Fleet is guaranteed to expire between ``13:30:55`` and ``14:30:55`` on ``5/31/2019`` .
        :param instance_match_criteria: Indicates the type of instance launches that the Capacity Reservation Fleet accepts. All Capacity Reservations in the Fleet inherit this instance matching criteria. Currently, Capacity Reservation Fleets support ``open`` instance matching criteria only. This means that instances that have matching attributes (instance type, platform, and Availability Zone) run in the Capacity Reservations automatically. Instances do not need to explicitly target a Capacity Reservation Fleet to use its reserved capacity.
        :param instance_type_specifications: Information about the instance types for which to reserve the capacity.
        :param no_remove_end_date: Used to add an end date to a Capacity Reservation Fleet that has no end date and time. To add an end date to a Capacity Reservation Fleet, specify ``true`` for this paramater and specify the end date and time (in UTC time format) for the *EndDate* parameter.
        :param remove_end_date: Used to remove an end date from a Capacity Reservation Fleet that is configured to end automatically at a specific date and time. To remove the end date from a Capacity Reservation Fleet, specify ``true`` for this paramater and omit the *EndDate* parameter.
        :param tag_specifications: The tags to assign to the Capacity Reservation Fleet. The tags are automatically assigned to the Capacity Reservations in the Fleet.
        :param tenancy: Indicates the tenancy of the Capacity Reservation Fleet. All Capacity Reservations in the Fleet inherit this tenancy. The Capacity Reservation Fleet can have one of the following tenancy settings: - ``default`` - The Capacity Reservation Fleet is created on hardware that is shared with other AWS accounts . - ``dedicated`` - The Capacity Reservations are created on single-tenant hardware that is dedicated to a single AWS account .
        :param total_target_capacity: The total number of capacity units to be reserved by the Capacity Reservation Fleet. This value, together with the instance type weights that you assign to each instance type used by the Fleet determine the number of instances for which the Fleet reserves capacity. Both values are based on units that make sense for your workload. For more information, see `Total target capacity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity>`_ in the Amazon EC2 User Guide.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6fb1af1f639a354aff6bb978bcac42ab042448e257770c8bed7a46897429542)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnCapacityReservationFleetProps(
            allocation_strategy=allocation_strategy,
            end_date=end_date,
            instance_match_criteria=instance_match_criteria,
            instance_type_specifications=instance_type_specifications,
            no_remove_end_date=no_remove_end_date,
            remove_end_date=remove_end_date,
            tag_specifications=tag_specifications,
            tenancy=tenancy,
            total_target_capacity=total_target_capacity,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35bd03d12bd6116122e660dadd70f4c4735a841ce1b9a702a966cfc70b2123d1)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12b0be9e7203b7b337996367bda0b1ef3d17273516ce9a44f5f9c1be5c34c081)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCapacityReservationFleetId")
    def attr_capacity_reservation_fleet_id(self) -> builtins.str:
        '''The ID of the Capacity Reservation Fleet.

        :cloudformationAttribute: CapacityReservationFleetId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCapacityReservationFleetId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="allocationStrategy")
    def allocation_strategy(self) -> typing.Optional[builtins.str]:
        '''The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "allocationStrategy"))

    @allocation_strategy.setter
    def allocation_strategy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff7425d803e147608940b2d4d46fa62c8f6d398dfda2f81c4d9daae76caa17bc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationStrategy", value)

    @builtins.property
    @jsii.member(jsii_name="endDate")
    def end_date(self) -> typing.Optional[builtins.str]:
        '''The date and time at which the Capacity Reservation Fleet expires.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "endDate"))

    @end_date.setter
    def end_date(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9be4232e54cc46f4b116770555b9dd460cb1f802b7496077e8e31ba3afd7cbff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "endDate", value)

    @builtins.property
    @jsii.member(jsii_name="instanceMatchCriteria")
    def instance_match_criteria(self) -> typing.Optional[builtins.str]:
        '''Indicates the type of instance launches that the Capacity Reservation Fleet accepts.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceMatchCriteria"))

    @instance_match_criteria.setter
    def instance_match_criteria(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__026984f5fc35753acd6fb74696c8208736dc28838b389118f458535c5762a672)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceMatchCriteria", value)

    @builtins.property
    @jsii.member(jsii_name="instanceTypeSpecifications")
    def instance_type_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.InstanceTypeSpecificationProperty"]]]]:
        '''Information about the instance types for which to reserve the capacity.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.InstanceTypeSpecificationProperty"]]]], jsii.get(self, "instanceTypeSpecifications"))

    @instance_type_specifications.setter
    def instance_type_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.InstanceTypeSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45208597646253fe188d8f1f2e5d2fa3ecdd988899be6ea30229a2132738df76)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceTypeSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="noRemoveEndDate")
    def no_remove_end_date(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Used to add an end date to a Capacity Reservation Fleet that has no end date and time.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "noRemoveEndDate"))

    @no_remove_end_date.setter
    def no_remove_end_date(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a98456c361af7e60a4e64d845a4bbe28b249e03540ffe9d59f96245e0f292752)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "noRemoveEndDate", value)

    @builtins.property
    @jsii.member(jsii_name="removeEndDate")
    def remove_end_date(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Used to remove an end date from a Capacity Reservation Fleet that is configured to end automatically at a specific date and time.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "removeEndDate"))

    @remove_end_date.setter
    def remove_end_date(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cfebbe0400b084370b4e45e01a83c61bb47ae01d37c14a2ac6591c4708c975a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "removeEndDate", value)

    @builtins.property
    @jsii.member(jsii_name="tagSpecifications")
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.TagSpecificationProperty"]]]]:
        '''The tags to assign to the Capacity Reservation Fleet.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.TagSpecificationProperty"]]]], jsii.get(self, "tagSpecifications"))

    @tag_specifications.setter
    def tag_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCapacityReservationFleet.TagSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9be24701036c5abd754bc67058ec4d8c733250163e5a63577648325991d133e9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="tenancy")
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''Indicates the tenancy of the Capacity Reservation Fleet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tenancy"))

    @tenancy.setter
    def tenancy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7dbdd25c7a6e3e88f44f955dc9784e01a01af6c00df012edb23a78014e0caae4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tenancy", value)

    @builtins.property
    @jsii.member(jsii_name="totalTargetCapacity")
    def total_target_capacity(self) -> typing.Optional[jsii.Number]:
        '''The total number of capacity units to be reserved by the Capacity Reservation Fleet.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "totalTargetCapacity"))

    @total_target_capacity.setter
    def total_target_capacity(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b98cc8f5cd84b2ab7c2779d1b5d483afac7074f27afc44e507d761ee2987489d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "totalTargetCapacity", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservationFleet.InstanceTypeSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "availability_zone": "availabilityZone",
            "availability_zone_id": "availabilityZoneId",
            "ebs_optimized": "ebsOptimized",
            "instance_platform": "instancePlatform",
            "instance_type": "instanceType",
            "priority": "priority",
            "weight": "weight",
        },
    )
    class InstanceTypeSpecificationProperty:
        def __init__(
            self,
            *,
            availability_zone: typing.Optional[builtins.str] = None,
            availability_zone_id: typing.Optional[builtins.str] = None,
            ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            instance_platform: typing.Optional[builtins.str] = None,
            instance_type: typing.Optional[builtins.str] = None,
            priority: typing.Optional[jsii.Number] = None,
            weight: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies information about an instance type to use in a Capacity Reservation Fleet.

            ``InstanceTypeSpecification`` is a property of the `AWS::EC2::CapacityReservationFleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html>`_ resource.

            :param availability_zone: The Availability Zone in which the Capacity Reservation Fleet reserves the capacity. A Capacity Reservation Fleet can't span Availability Zones. All instance type specifications that you specify for the Fleet must use the same Availability Zone.
            :param availability_zone_id: The ID of the Availability Zone in which the Capacity Reservation Fleet reserves the capacity. A Capacity Reservation Fleet can't span Availability Zones. All instance type specifications that you specify for the Fleet must use the same Availability Zone.
            :param ebs_optimized: Indicates whether the Capacity Reservation Fleet supports EBS-optimized instances types. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using EBS-optimized instance types.
            :param instance_platform: The type of operating system for which the Capacity Reservation Fleet reserves capacity.
            :param instance_type: The instance type for which the Capacity Reservation Fleet reserves capacity.
            :param priority: The priority to assign to the instance type. This value is used to determine which of the instance types specified for the Fleet should be prioritized for use. A lower value indicates a high priority. For more information, see `Instance type priority <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-priority>`_ in the Amazon EC2 User Guide.
            :param weight: The number of capacity units provided by the specified instance type. This value, together with the total target capacity that you specify for the Fleet determine the number of instances for which the Fleet reserves capacity. Both values are based on units that make sense for your workload. For more information, see `Total target capacity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity>`_ in the Amazon EC2 User Guide. Valid Range: Minimum value of ``0.001`` . Maximum value of ``99.999`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_type_specification_property = ec2.CfnCapacityReservationFleet.InstanceTypeSpecificationProperty(
                    availability_zone="availabilityZone",
                    availability_zone_id="availabilityZoneId",
                    ebs_optimized=False,
                    instance_platform="instancePlatform",
                    instance_type="instanceType",
                    priority=123,
                    weight=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1f03a957255637b5857219e572d51eadfa10b8ad587bd37cf340d9e7c2231d21)
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument availability_zone_id", value=availability_zone_id, expected_type=type_hints["availability_zone_id"])
                check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
                check_type(argname="argument instance_platform", value=instance_platform, expected_type=type_hints["instance_platform"])
                check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
                check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if availability_zone_id is not None:
                self._values["availability_zone_id"] = availability_zone_id
            if ebs_optimized is not None:
                self._values["ebs_optimized"] = ebs_optimized
            if instance_platform is not None:
                self._values["instance_platform"] = instance_platform
            if instance_type is not None:
                self._values["instance_type"] = instance_type
            if priority is not None:
                self._values["priority"] = priority
            if weight is not None:
                self._values["weight"] = weight

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone in which the Capacity Reservation Fleet reserves the capacity.

            A Capacity Reservation Fleet can't span Availability Zones. All instance type specifications that you specify for the Fleet must use the same Availability Zone.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def availability_zone_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the Availability Zone in which the Capacity Reservation Fleet reserves the capacity.

            A Capacity Reservation Fleet can't span Availability Zones. All instance type specifications that you specify for the Fleet must use the same Availability Zone.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-availabilityzoneid
            '''
            result = self._values.get("availability_zone_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ebs_optimized(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the Capacity Reservation Fleet supports EBS-optimized instances types.

            This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using EBS-optimized instance types.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-ebsoptimized
            '''
            result = self._values.get("ebs_optimized")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def instance_platform(self) -> typing.Optional[builtins.str]:
            '''The type of operating system for which the Capacity Reservation Fleet reserves capacity.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-instanceplatform
            '''
            result = self._values.get("instance_platform")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_type(self) -> typing.Optional[builtins.str]:
            '''The instance type for which the Capacity Reservation Fleet reserves capacity.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-instancetype
            '''
            result = self._values.get("instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def priority(self) -> typing.Optional[jsii.Number]:
            '''The priority to assign to the instance type.

            This value is used to determine which of the instance types specified for the Fleet should be prioritized for use. A lower value indicates a high priority. For more information, see `Instance type priority <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#instance-priority>`_ in the Amazon EC2 User Guide.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-priority
            '''
            result = self._values.get("priority")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def weight(self) -> typing.Optional[jsii.Number]:
            '''The number of capacity units provided by the specified instance type.

            This value, together with the total target capacity that you specify for the Fleet determine the number of instances for which the Fleet reserves capacity. Both values are based on units that make sense for your workload. For more information, see `Total target capacity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity>`_ in the Amazon EC2 User Guide.

            Valid Range: Minimum value of ``0.001`` . Maximum value of ``99.999`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-instancetypespecification.html#cfn-ec2-capacityreservationfleet-instancetypespecification-weight
            '''
            result = self._values.get("weight")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceTypeSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservationFleet.TagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class TagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The tags to apply to a resource when the resource is being created.

            When you specify a tag, you must specify the resource type to tag, otherwise the request will fail.
            .. epigraph::

               The ``Valid Values`` lists all the resource types that can be tagged. However, the action you're using might not support tagging all of these resource types. If you try to tag a resource type that is unsupported for the action you're using, you'll get an error.

            :param resource_type: The type of resource to tag on creation. Specify ``capacity-reservation-fleet`` . To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ .
            :param tags: The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-tagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                tag_specification_property = ec2.CfnCapacityReservationFleet.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__2494957f49f85b50a915390ad0dfbf5c119ba87d5b7f2a04a0d67766b4901d34)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource to tag on creation. Specify ``capacity-reservation-fleet`` .

            To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-tagspecification.html#cfn-ec2-capacityreservationfleet-tagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-capacityreservationfleet-tagspecification.html#cfn-ec2-capacityreservationfleet-tagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservationFleetProps",
    jsii_struct_bases=[],
    name_mapping={
        "allocation_strategy": "allocationStrategy",
        "end_date": "endDate",
        "instance_match_criteria": "instanceMatchCriteria",
        "instance_type_specifications": "instanceTypeSpecifications",
        "no_remove_end_date": "noRemoveEndDate",
        "remove_end_date": "removeEndDate",
        "tag_specifications": "tagSpecifications",
        "tenancy": "tenancy",
        "total_target_capacity": "totalTargetCapacity",
    },
)
class CfnCapacityReservationFleetProps:
    def __init__(
        self,
        *,
        allocation_strategy: typing.Optional[builtins.str] = None,
        end_date: typing.Optional[builtins.str] = None,
        instance_match_criteria: typing.Optional[builtins.str] = None,
        instance_type_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.InstanceTypeSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        no_remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
        total_target_capacity: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnCapacityReservationFleet``.

        :param allocation_strategy: The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use. Currently, only the ``prioritized`` allocation strategy is supported. For more information, see `Allocation strategy <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy>`_ in the Amazon EC2 User Guide. Valid values: ``prioritized``
        :param end_date: The date and time at which the Capacity Reservation Fleet expires. When the Capacity Reservation Fleet expires, its state changes to ``expired`` and all of the Capacity Reservations in the Fleet expire. The Capacity Reservation Fleet expires within an hour after the specified time. For example, if you specify ``5/31/2019`` , ``13:30:55`` , the Capacity Reservation Fleet is guaranteed to expire between ``13:30:55`` and ``14:30:55`` on ``5/31/2019`` .
        :param instance_match_criteria: Indicates the type of instance launches that the Capacity Reservation Fleet accepts. All Capacity Reservations in the Fleet inherit this instance matching criteria. Currently, Capacity Reservation Fleets support ``open`` instance matching criteria only. This means that instances that have matching attributes (instance type, platform, and Availability Zone) run in the Capacity Reservations automatically. Instances do not need to explicitly target a Capacity Reservation Fleet to use its reserved capacity.
        :param instance_type_specifications: Information about the instance types for which to reserve the capacity.
        :param no_remove_end_date: Used to add an end date to a Capacity Reservation Fleet that has no end date and time. To add an end date to a Capacity Reservation Fleet, specify ``true`` for this paramater and specify the end date and time (in UTC time format) for the *EndDate* parameter.
        :param remove_end_date: Used to remove an end date from a Capacity Reservation Fleet that is configured to end automatically at a specific date and time. To remove the end date from a Capacity Reservation Fleet, specify ``true`` for this paramater and omit the *EndDate* parameter.
        :param tag_specifications: The tags to assign to the Capacity Reservation Fleet. The tags are automatically assigned to the Capacity Reservations in the Fleet.
        :param tenancy: Indicates the tenancy of the Capacity Reservation Fleet. All Capacity Reservations in the Fleet inherit this tenancy. The Capacity Reservation Fleet can have one of the following tenancy settings: - ``default`` - The Capacity Reservation Fleet is created on hardware that is shared with other AWS accounts . - ``dedicated`` - The Capacity Reservations are created on single-tenant hardware that is dedicated to a single AWS account .
        :param total_target_capacity: The total number of capacity units to be reserved by the Capacity Reservation Fleet. This value, together with the instance type weights that you assign to each instance type used by the Fleet determine the number of instances for which the Fleet reserves capacity. Both values are based on units that make sense for your workload. For more information, see `Total target capacity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity>`_ in the Amazon EC2 User Guide.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_capacity_reservation_fleet_props = ec2.CfnCapacityReservationFleetProps(
                allocation_strategy="allocationStrategy",
                end_date="endDate",
                instance_match_criteria="instanceMatchCriteria",
                instance_type_specifications=[ec2.CfnCapacityReservationFleet.InstanceTypeSpecificationProperty(
                    availability_zone="availabilityZone",
                    availability_zone_id="availabilityZoneId",
                    ebs_optimized=False,
                    instance_platform="instancePlatform",
                    instance_type="instanceType",
                    priority=123,
                    weight=123
                )],
                no_remove_end_date=False,
                remove_end_date=False,
                tag_specifications=[ec2.CfnCapacityReservationFleet.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )],
                tenancy="tenancy",
                total_target_capacity=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__43bd0a52cfe7402bf156151a3e760ed1bd133935bd29982a3798f854cbee5064)
            check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
            check_type(argname="argument end_date", value=end_date, expected_type=type_hints["end_date"])
            check_type(argname="argument instance_match_criteria", value=instance_match_criteria, expected_type=type_hints["instance_match_criteria"])
            check_type(argname="argument instance_type_specifications", value=instance_type_specifications, expected_type=type_hints["instance_type_specifications"])
            check_type(argname="argument no_remove_end_date", value=no_remove_end_date, expected_type=type_hints["no_remove_end_date"])
            check_type(argname="argument remove_end_date", value=remove_end_date, expected_type=type_hints["remove_end_date"])
            check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
            check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
            check_type(argname="argument total_target_capacity", value=total_target_capacity, expected_type=type_hints["total_target_capacity"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if allocation_strategy is not None:
            self._values["allocation_strategy"] = allocation_strategy
        if end_date is not None:
            self._values["end_date"] = end_date
        if instance_match_criteria is not None:
            self._values["instance_match_criteria"] = instance_match_criteria
        if instance_type_specifications is not None:
            self._values["instance_type_specifications"] = instance_type_specifications
        if no_remove_end_date is not None:
            self._values["no_remove_end_date"] = no_remove_end_date
        if remove_end_date is not None:
            self._values["remove_end_date"] = remove_end_date
        if tag_specifications is not None:
            self._values["tag_specifications"] = tag_specifications
        if tenancy is not None:
            self._values["tenancy"] = tenancy
        if total_target_capacity is not None:
            self._values["total_target_capacity"] = total_target_capacity

    @builtins.property
    def allocation_strategy(self) -> typing.Optional[builtins.str]:
        '''The strategy used by the Capacity Reservation Fleet to determine which of the specified instance types to use.

        Currently, only the ``prioritized`` allocation strategy is supported. For more information, see `Allocation strategy <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy>`_ in the Amazon EC2 User Guide.

        Valid values: ``prioritized``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-allocationstrategy
        '''
        result = self._values.get("allocation_strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def end_date(self) -> typing.Optional[builtins.str]:
        '''The date and time at which the Capacity Reservation Fleet expires.

        When the Capacity Reservation Fleet expires, its state changes to ``expired`` and all of the Capacity Reservations in the Fleet expire.

        The Capacity Reservation Fleet expires within an hour after the specified time. For example, if you specify ``5/31/2019`` , ``13:30:55`` , the Capacity Reservation Fleet is guaranteed to expire between ``13:30:55`` and ``14:30:55`` on ``5/31/2019`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-enddate
        '''
        result = self._values.get("end_date")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_match_criteria(self) -> typing.Optional[builtins.str]:
        '''Indicates the type of instance launches that the Capacity Reservation Fleet accepts.

        All Capacity Reservations in the Fleet inherit this instance matching criteria.

        Currently, Capacity Reservation Fleets support ``open`` instance matching criteria only. This means that instances that have matching attributes (instance type, platform, and Availability Zone) run in the Capacity Reservations automatically. Instances do not need to explicitly target a Capacity Reservation Fleet to use its reserved capacity.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-instancematchcriteria
        '''
        result = self._values.get("instance_match_criteria")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_type_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.InstanceTypeSpecificationProperty]]]]:
        '''Information about the instance types for which to reserve the capacity.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-instancetypespecifications
        '''
        result = self._values.get("instance_type_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.InstanceTypeSpecificationProperty]]]], result)

    @builtins.property
    def no_remove_end_date(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Used to add an end date to a Capacity Reservation Fleet that has no end date and time.

        To add an end date to a Capacity Reservation Fleet, specify ``true`` for this paramater and specify the end date and time (in UTC time format) for the *EndDate* parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-noremoveenddate
        '''
        result = self._values.get("no_remove_end_date")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def remove_end_date(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Used to remove an end date from a Capacity Reservation Fleet that is configured to end automatically at a specific date and time.

        To remove the end date from a Capacity Reservation Fleet, specify ``true`` for this paramater and omit the *EndDate* parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-removeenddate
        '''
        result = self._values.get("remove_end_date")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.TagSpecificationProperty]]]]:
        '''The tags to assign to the Capacity Reservation Fleet.

        The tags are automatically assigned to the Capacity Reservations in the Fleet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-tagspecifications
        '''
        result = self._values.get("tag_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.TagSpecificationProperty]]]], result)

    @builtins.property
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''Indicates the tenancy of the Capacity Reservation Fleet.

        All Capacity Reservations in the Fleet inherit this tenancy. The Capacity Reservation Fleet can have one of the following tenancy settings:

        - ``default`` - The Capacity Reservation Fleet is created on hardware that is shared with other AWS accounts .
        - ``dedicated`` - The Capacity Reservations are created on single-tenant hardware that is dedicated to a single AWS account .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-tenancy
        '''
        result = self._values.get("tenancy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def total_target_capacity(self) -> typing.Optional[jsii.Number]:
        '''The total number of capacity units to be reserved by the Capacity Reservation Fleet.

        This value, together with the instance type weights that you assign to each instance type used by the Fleet determine the number of instances for which the Fleet reserves capacity. Both values are based on units that make sense for your workload. For more information, see `Total target capacity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity>`_ in the Amazon EC2 User Guide.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservationfleet.html#cfn-ec2-capacityreservationfleet-totaltargetcapacity
        '''
        result = self._values.get("total_target_capacity")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnCapacityReservationFleetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnCapacityReservationProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "instance_count": "instanceCount",
        "instance_platform": "instancePlatform",
        "instance_type": "instanceType",
        "ebs_optimized": "ebsOptimized",
        "end_date": "endDate",
        "end_date_type": "endDateType",
        "ephemeral_storage": "ephemeralStorage",
        "instance_match_criteria": "instanceMatchCriteria",
        "out_post_arn": "outPostArn",
        "placement_group_arn": "placementGroupArn",
        "tag_specifications": "tagSpecifications",
        "tenancy": "tenancy",
    },
)
class CfnCapacityReservationProps:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        instance_count: jsii.Number,
        instance_platform: builtins.str,
        instance_type: builtins.str,
        ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        end_date: typing.Optional[builtins.str] = None,
        end_date_type: typing.Optional[builtins.str] = None,
        ephemeral_storage: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        instance_match_criteria: typing.Optional[builtins.str] = None,
        out_post_arn: typing.Optional[builtins.str] = None,
        placement_group_arn: typing.Optional[builtins.str] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservation.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnCapacityReservation``.

        :param availability_zone: The Availability Zone in which to create the Capacity Reservation.
        :param instance_count: The number of instances for which to reserve capacity. Valid range: 1 - 1000
        :param instance_platform: The type of operating system for which to reserve capacity.
        :param instance_type: The instance type for which to reserve capacity. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .
        :param ebs_optimized: Indicates whether the Capacity Reservation supports EBS-optimized instances. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS- optimized instance.
        :param end_date: The date and time at which the Capacity Reservation expires. When a Capacity Reservation expires, the reserved capacity is released and you can no longer launch instances into it. The Capacity Reservation's state changes to ``expired`` when it reaches its end date and time. You must provide an ``EndDate`` value if ``EndDateType`` is ``limited`` . Omit ``EndDate`` if ``EndDateType`` is ``unlimited`` . If the ``EndDateType`` is ``limited`` , the Capacity Reservation is cancelled within an hour from the specified time. For example, if you specify 5/31/2019, 13:30:55, the Capacity Reservation is guaranteed to end between 13:30:55 and 14:30:55 on 5/31/2019.
        :param end_date_type: Indicates the way in which the Capacity Reservation ends. A Capacity Reservation can have one of the following end types: - ``unlimited`` - The Capacity Reservation remains active until you explicitly cancel it. Do not provide an ``EndDate`` if the ``EndDateType`` is ``unlimited`` . - ``limited`` - The Capacity Reservation expires automatically at a specified date and time. You must provide an ``EndDate`` value if the ``EndDateType`` value is ``limited`` .
        :param ephemeral_storage: *Deprecated.*.
        :param instance_match_criteria: Indicates the type of instance launches that the Capacity Reservation accepts. The options include:. - ``open`` - The Capacity Reservation automatically matches all instances that have matching attributes (instance type, platform, and Availability Zone). Instances that have matching attributes run in the Capacity Reservation automatically without specifying any additional parameters. - ``targeted`` - The Capacity Reservation only accepts instances that have matching attributes (instance type, platform, and Availability Zone), and explicitly target the Capacity Reservation. This ensures that only permitted instances can use the reserved capacity. Default: ``open``
        :param out_post_arn: The Amazon Resource Name (ARN) of the Outpost on which to create the Capacity Reservation.
        :param placement_group_arn: The Amazon Resource Name (ARN) of the cluster placement group in which to create the Capacity Reservation. For more information, see `Capacity Reservations for cluster placement groups <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-cpg.html>`_ in the *Amazon EC2 User Guide* .
        :param tag_specifications: The tags to apply to the Capacity Reservation during launch.
        :param tenancy: Indicates the tenancy of the Capacity Reservation. A Capacity Reservation can have one of the following tenancy settings:. - ``default`` - The Capacity Reservation is created on hardware that is shared with other AWS accounts . - ``dedicated`` - The Capacity Reservation is created on single-tenant hardware that is dedicated to a single AWS account .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_capacity_reservation_props = ec2.CfnCapacityReservationProps(
                availability_zone="availabilityZone",
                instance_count=123,
                instance_platform="instancePlatform",
                instance_type="instanceType",
            
                # the properties below are optional
                ebs_optimized=False,
                end_date="endDate",
                end_date_type="endDateType",
                ephemeral_storage=False,
                instance_match_criteria="instanceMatchCriteria",
                out_post_arn="outPostArn",
                placement_group_arn="placementGroupArn",
                tag_specifications=[ec2.CfnCapacityReservation.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )],
                tenancy="tenancy"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a65d4e8bb2e678a9a6387fd809c3b5428c783211224ece5155ec92d1eda301d)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument instance_count", value=instance_count, expected_type=type_hints["instance_count"])
            check_type(argname="argument instance_platform", value=instance_platform, expected_type=type_hints["instance_platform"])
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
            check_type(argname="argument end_date", value=end_date, expected_type=type_hints["end_date"])
            check_type(argname="argument end_date_type", value=end_date_type, expected_type=type_hints["end_date_type"])
            check_type(argname="argument ephemeral_storage", value=ephemeral_storage, expected_type=type_hints["ephemeral_storage"])
            check_type(argname="argument instance_match_criteria", value=instance_match_criteria, expected_type=type_hints["instance_match_criteria"])
            check_type(argname="argument out_post_arn", value=out_post_arn, expected_type=type_hints["out_post_arn"])
            check_type(argname="argument placement_group_arn", value=placement_group_arn, expected_type=type_hints["placement_group_arn"])
            check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
            check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "instance_count": instance_count,
            "instance_platform": instance_platform,
            "instance_type": instance_type,
        }
        if ebs_optimized is not None:
            self._values["ebs_optimized"] = ebs_optimized
        if end_date is not None:
            self._values["end_date"] = end_date
        if end_date_type is not None:
            self._values["end_date_type"] = end_date_type
        if ephemeral_storage is not None:
            self._values["ephemeral_storage"] = ephemeral_storage
        if instance_match_criteria is not None:
            self._values["instance_match_criteria"] = instance_match_criteria
        if out_post_arn is not None:
            self._values["out_post_arn"] = out_post_arn
        if placement_group_arn is not None:
            self._values["placement_group_arn"] = placement_group_arn
        if tag_specifications is not None:
            self._values["tag_specifications"] = tag_specifications
        if tenancy is not None:
            self._values["tenancy"] = tenancy

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone in which to create the Capacity Reservation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-availabilityzone
        '''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def instance_count(self) -> jsii.Number:
        '''The number of instances for which to reserve capacity.

        Valid range: 1 - 1000

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-instancecount
        '''
        result = self._values.get("instance_count")
        assert result is not None, "Required property 'instance_count' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def instance_platform(self) -> builtins.str:
        '''The type of operating system for which to reserve capacity.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-instanceplatform
        '''
        result = self._values.get("instance_platform")
        assert result is not None, "Required property 'instance_platform' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def instance_type(self) -> builtins.str:
        '''The instance type for which to reserve capacity.

        For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-instancetype
        '''
        result = self._values.get("instance_type")
        assert result is not None, "Required property 'instance_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ebs_optimized(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the Capacity Reservation supports EBS-optimized instances.

        This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS- optimized instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-ebsoptimized
        '''
        result = self._values.get("ebs_optimized")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def end_date(self) -> typing.Optional[builtins.str]:
        '''The date and time at which the Capacity Reservation expires.

        When a Capacity Reservation expires, the reserved capacity is released and you can no longer launch instances into it. The Capacity Reservation's state changes to ``expired`` when it reaches its end date and time.

        You must provide an ``EndDate`` value if ``EndDateType`` is ``limited`` . Omit ``EndDate`` if ``EndDateType`` is ``unlimited`` .

        If the ``EndDateType`` is ``limited`` , the Capacity Reservation is cancelled within an hour from the specified time. For example, if you specify 5/31/2019, 13:30:55, the Capacity Reservation is guaranteed to end between 13:30:55 and 14:30:55 on 5/31/2019.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-enddate
        '''
        result = self._values.get("end_date")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def end_date_type(self) -> typing.Optional[builtins.str]:
        '''Indicates the way in which the Capacity Reservation ends.

        A Capacity Reservation can have one of the following end types:

        - ``unlimited`` - The Capacity Reservation remains active until you explicitly cancel it. Do not provide an ``EndDate`` if the ``EndDateType`` is ``unlimited`` .
        - ``limited`` - The Capacity Reservation expires automatically at a specified date and time. You must provide an ``EndDate`` value if the ``EndDateType`` value is ``limited`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-enddatetype
        '''
        result = self._values.get("end_date_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ephemeral_storage(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''*Deprecated.*.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-ephemeralstorage
        '''
        result = self._values.get("ephemeral_storage")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def instance_match_criteria(self) -> typing.Optional[builtins.str]:
        '''Indicates the type of instance launches that the Capacity Reservation accepts. The options include:.

        - ``open`` - The Capacity Reservation automatically matches all instances that have matching attributes (instance type, platform, and Availability Zone). Instances that have matching attributes run in the Capacity Reservation automatically without specifying any additional parameters.
        - ``targeted`` - The Capacity Reservation only accepts instances that have matching attributes (instance type, platform, and Availability Zone), and explicitly target the Capacity Reservation. This ensures that only permitted instances can use the reserved capacity.

        Default: ``open``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-instancematchcriteria
        '''
        result = self._values.get("instance_match_criteria")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def out_post_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost on which to create the Capacity Reservation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-outpostarn
        '''
        result = self._values.get("out_post_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def placement_group_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the cluster placement group in which to create the Capacity Reservation.

        For more information, see `Capacity Reservations for cluster placement groups <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cr-cpg.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-placementgrouparn
        '''
        result = self._values.get("placement_group_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservation.TagSpecificationProperty]]]]:
        '''The tags to apply to the Capacity Reservation during launch.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-tagspecifications
        '''
        result = self._values.get("tag_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservation.TagSpecificationProperty]]]], result)

    @builtins.property
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''Indicates the tenancy of the Capacity Reservation. A Capacity Reservation can have one of the following tenancy settings:.

        - ``default`` - The Capacity Reservation is created on hardware that is shared with other AWS accounts .
        - ``dedicated`` - The Capacity Reservation is created on single-tenant hardware that is dedicated to a single AWS account .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-capacityreservation.html#cfn-ec2-capacityreservation-tenancy
        '''
        result = self._values.get("tenancy")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnCapacityReservationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnCarrierGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnCarrierGateway",
):
    '''Creates a carrier gateway.

    For more information about carrier gateways, see `Carrier gateways <https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#wavelength-carrier-gateway>`_ in the *AWS Wavelength Developer Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-carriergateway.html
    :cloudformationResource: AWS::EC2::CarrierGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_carrier_gateway = ec2.CfnCarrierGateway(self, "MyCfnCarrierGateway",
            vpc_id="vpcId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC associated with the carrier gateway.
        :param tags: The tags assigned to the carrier gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a96681cf286606ecadca18bda0ea89ce2bcb5ccb239c0ee8192648a3c637a8b7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnCarrierGatewayProps(vpc_id=vpc_id, tags=tags)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d13b490de5a71d5c115db0ab3676eac3623d858382e7bda0f72126bd9502de90)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__90ea968688bd5c8f89a44e36535e084f93c6f71eba72008a7c8fae86793c0259)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCarrierGatewayId")
    def attr_carrier_gateway_id(self) -> builtins.str:
        '''The ID of the carrier gateway.

        :cloudformationAttribute: CarrierGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCarrierGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The AWS account ID of the owner of the carrier gateway.

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the carrier gateway.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC associated with the carrier gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ebb550f90f423a1cfb12d6962e0d7086e672a69ebc839b263de830334bc029ed)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the carrier gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0dfc5813551a9e82e5f55d72a506cf1c303b862a6feb2c37161876bb3709f183)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnCarrierGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"vpc_id": "vpcId", "tags": "tags"},
)
class CfnCarrierGatewayProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnCarrierGateway``.

        :param vpc_id: The ID of the VPC associated with the carrier gateway.
        :param tags: The tags assigned to the carrier gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-carriergateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_carrier_gateway_props = ec2.CfnCarrierGatewayProps(
                vpc_id="vpcId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3bbc37c06b02209086fba1b3fa469d662917ffbfa06787d6aa230add064812b5)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC associated with the carrier gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-carriergateway.html#cfn-ec2-carriergateway-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the carrier gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-carriergateway.html#cfn-ec2-carriergateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnCarrierGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnClientVpnAuthorizationRule(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnAuthorizationRule",
):
    '''Specifies an ingress authorization rule to add to a Client VPN endpoint.

    Ingress authorization rules act as firewall rules that grant access to networks. You must configure ingress authorization rules to enable clients to access resources in AWS or on-premises networks.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html
    :cloudformationResource: AWS::EC2::ClientVpnAuthorizationRule
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_client_vpn_authorization_rule = ec2.CfnClientVpnAuthorizationRule(self, "MyCfnClientVpnAuthorizationRule",
            client_vpn_endpoint_id="clientVpnEndpointId",
            target_network_cidr="targetNetworkCidr",
        
            # the properties below are optional
            access_group_id="accessGroupId",
            authorize_all_groups=False,
            description="description"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        client_vpn_endpoint_id: builtins.str,
        target_network_cidr: builtins.str,
        access_group_id: typing.Optional[builtins.str] = None,
        authorize_all_groups: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint.
        :param target_network_cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param access_group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Required if ``AuthorizeAllGroups`` is ``false`` or not specified.
        :param authorize_all_groups: Indicates whether to grant access to all clients. Specify ``true`` to grant all clients who successfully establish a VPN connection access to the network. Must be set to ``true`` if ``AccessGroupId`` is not specified.
        :param description: A brief description of the authorization rule.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd74bb129f8a2ee17c8ff18f5e8a8159b69611f04a07a0ba8d4ee6559e6cdcf1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnClientVpnAuthorizationRuleProps(
            client_vpn_endpoint_id=client_vpn_endpoint_id,
            target_network_cidr=target_network_cidr,
            access_group_id=access_group_id,
            authorize_all_groups=authorize_all_groups,
            description=description,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d12a489bd88f39a7168ebfe201bff6cf3289493f7b5afa2b2922bc47aa6c2c68)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3c2c11aee50519461eefce28d36cb3da24e82c98ec6ae92b06453da946e1d378)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="clientVpnEndpointId")
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "clientVpnEndpointId"))

    @client_vpn_endpoint_id.setter
    def client_vpn_endpoint_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50e6d04c1e7523cd5b1e3a8aa7e8300bd0269bc5af9b74b075b07f8a571ee275)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientVpnEndpointId", value)

    @builtins.property
    @jsii.member(jsii_name="targetNetworkCidr")
    def target_network_cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the network for which access is being authorized.'''
        return typing.cast(builtins.str, jsii.get(self, "targetNetworkCidr"))

    @target_network_cidr.setter
    def target_network_cidr(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__56d17686cc15e94936303baff8d4eedc73db3f1a2eeb09ce0187cc9c3009b3fa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "targetNetworkCidr", value)

    @builtins.property
    @jsii.member(jsii_name="accessGroupId")
    def access_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "accessGroupId"))

    @access_group_id.setter
    def access_group_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6e18292fe4463a8537a7530cceaa1f4005c5deba7137c98197919623660f02c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "accessGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="authorizeAllGroups")
    def authorize_all_groups(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to grant access to all clients.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "authorizeAllGroups"))

    @authorize_all_groups.setter
    def authorize_all_groups(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__23a4fad72febaec5f7897b0f2d2dc6091bb1118a92f232e90857a191a9149282)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "authorizeAllGroups", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a0b70f87d13c22c58248897e96db8448f527f13ea896b4d14ed47955f79b9e3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnAuthorizationRuleProps",
    jsii_struct_bases=[],
    name_mapping={
        "client_vpn_endpoint_id": "clientVpnEndpointId",
        "target_network_cidr": "targetNetworkCidr",
        "access_group_id": "accessGroupId",
        "authorize_all_groups": "authorizeAllGroups",
        "description": "description",
    },
)
class CfnClientVpnAuthorizationRuleProps:
    def __init__(
        self,
        *,
        client_vpn_endpoint_id: builtins.str,
        target_network_cidr: builtins.str,
        access_group_id: typing.Optional[builtins.str] = None,
        authorize_all_groups: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnClientVpnAuthorizationRule``.

        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint.
        :param target_network_cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param access_group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Required if ``AuthorizeAllGroups`` is ``false`` or not specified.
        :param authorize_all_groups: Indicates whether to grant access to all clients. Specify ``true`` to grant all clients who successfully establish a VPN connection access to the network. Must be set to ``true`` if ``AccessGroupId`` is not specified.
        :param description: A brief description of the authorization rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_client_vpn_authorization_rule_props = ec2.CfnClientVpnAuthorizationRuleProps(
                client_vpn_endpoint_id="clientVpnEndpointId",
                target_network_cidr="targetNetworkCidr",
            
                # the properties below are optional
                access_group_id="accessGroupId",
                authorize_all_groups=False,
                description="description"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1cce0b54049d26d96ca01a40dc238215d295ed1ab60e488a987cb2bafe1a791)
            check_type(argname="argument client_vpn_endpoint_id", value=client_vpn_endpoint_id, expected_type=type_hints["client_vpn_endpoint_id"])
            check_type(argname="argument target_network_cidr", value=target_network_cidr, expected_type=type_hints["target_network_cidr"])
            check_type(argname="argument access_group_id", value=access_group_id, expected_type=type_hints["access_group_id"])
            check_type(argname="argument authorize_all_groups", value=authorize_all_groups, expected_type=type_hints["authorize_all_groups"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "client_vpn_endpoint_id": client_vpn_endpoint_id,
            "target_network_cidr": target_network_cidr,
        }
        if access_group_id is not None:
            self._values["access_group_id"] = access_group_id
        if authorize_all_groups is not None:
            self._values["authorize_all_groups"] = authorize_all_groups
        if description is not None:
            self._values["description"] = description

    @builtins.property
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html#cfn-ec2-clientvpnauthorizationrule-clientvpnendpointid
        '''
        result = self._values.get("client_vpn_endpoint_id")
        assert result is not None, "Required property 'client_vpn_endpoint_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def target_network_cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the network for which access is being authorized.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html#cfn-ec2-clientvpnauthorizationrule-targetnetworkcidr
        '''
        result = self._values.get("target_network_cidr")
        assert result is not None, "Required property 'target_network_cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def access_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group.

        Required if ``AuthorizeAllGroups`` is ``false`` or not specified.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html#cfn-ec2-clientvpnauthorizationrule-accessgroupid
        '''
        result = self._values.get("access_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def authorize_all_groups(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to grant access to all clients.

        Specify ``true`` to grant all clients who successfully establish a VPN connection access to the network. Must be set to ``true`` if ``AccessGroupId`` is not specified.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html#cfn-ec2-clientvpnauthorizationrule-authorizeallgroups
        '''
        result = self._values.get("authorize_all_groups")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnauthorizationrule.html#cfn-ec2-clientvpnauthorizationrule-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnClientVpnAuthorizationRuleProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnClientVpnEndpoint(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint",
):
    '''Specifies a Client VPN endpoint.

    A Client VPN endpoint is the resource you create and configure to enable and manage client VPN sessions. It is the destination endpoint at which all client VPN sessions are terminated.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html
    :cloudformationResource: AWS::EC2::ClientVpnEndpoint
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_client_vpn_endpoint = ec2.CfnClientVpnEndpoint(self, "MyCfnClientVpnEndpoint",
            authentication_options=[ec2.CfnClientVpnEndpoint.ClientAuthenticationRequestProperty(
                type="type",
        
                # the properties below are optional
                active_directory=ec2.CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty(
                    directory_id="directoryId"
                ),
                federated_authentication=ec2.CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty(
                    saml_provider_arn="samlProviderArn",
        
                    # the properties below are optional
                    self_service_saml_provider_arn="selfServiceSamlProviderArn"
                ),
                mutual_authentication=ec2.CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty(
                    client_root_certificate_chain_arn="clientRootCertificateChainArn"
                )
            )],
            client_cidr_block="clientCidrBlock",
            connection_log_options=ec2.CfnClientVpnEndpoint.ConnectionLogOptionsProperty(
                enabled=False,
        
                # the properties below are optional
                cloudwatch_log_group="cloudwatchLogGroup",
                cloudwatch_log_stream="cloudwatchLogStream"
            ),
            server_certificate_arn="serverCertificateArn",
        
            # the properties below are optional
            client_connect_options=ec2.CfnClientVpnEndpoint.ClientConnectOptionsProperty(
                enabled=False,
        
                # the properties below are optional
                lambda_function_arn="lambdaFunctionArn"
            ),
            client_login_banner_options=ec2.CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty(
                enabled=False,
        
                # the properties below are optional
                banner_text="bannerText"
            ),
            client_route_monitoring_options=ec2.CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty(
                enabled=False
            ),
            description="description",
            dns_servers=["dnsServers"],
            security_group_ids=["securityGroupIds"],
            self_service_portal="selfServicePortal",
            session_timeout_hours=123,
            split_tunnel=False,
            tag_specifications=[ec2.CfnClientVpnEndpoint.TagSpecificationProperty(
                resource_type="resourceType",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )],
            transport_protocol="transportProtocol",
            vpc_id="vpcId",
            vpn_port=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        authentication_options: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.ClientAuthenticationRequestProperty", typing.Dict[builtins.str, typing.Any]]]]],
        client_cidr_block: builtins.str,
        connection_log_options: typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.ConnectionLogOptionsProperty", typing.Dict[builtins.str, typing.Any]]],
        server_certificate_arn: builtins.str,
        client_connect_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.ClientConnectOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        client_login_banner_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        client_route_monitoring_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        self_service_portal: typing.Optional[builtins.str] = None,
        session_timeout_hours: typing.Optional[jsii.Number] = None,
        split_tunnel: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.TagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        transport_protocol: typing.Optional[builtins.str] = None,
        vpc_id: typing.Optional[builtins.str] = None,
        vpn_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param authentication_options: Information about the authentication method to be used to authenticate clients.
        :param client_cidr_block: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. The address range cannot be changed after the Client VPN endpoint has been created. Client CIDR range must have a size of at least /22 and must not be greater than /12.
        :param connection_log_options: Information about the client connection logging options. If you enable client connection logging, data about client connections is sent to a Cloudwatch Logs log stream. The following information is logged: - Client connection requests - Client connection results (successful and unsuccessful) - Reasons for unsuccessful client connection requests - Client connection termination time
        :param server_certificate_arn: The ARN of the server certificate. For more information, see the `AWS Certificate Manager User Guide <https://docs.aws.amazon.com/acm/latest/userguide/>`_ .
        :param client_connect_options: The options for managing connection authorization for new client connections.
        :param client_login_banner_options: Options for enabling a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.
        :param client_route_monitoring_options: 
        :param description: A brief description of the Client VPN endpoint.
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. If no DNS server is specified, the DNS address configured on the device is used for the DNS server.
        :param security_group_ids: The IDs of one or more security groups to apply to the target network. You must also specify the ID of the VPC that contains the security groups.
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default Value: ``enabled``
        :param session_timeout_hours: The maximum VPN session duration time in hours. Valid values: ``8 | 10 | 12 | 24`` Default value: ``24``
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. By default, split-tunnel on a VPN endpoint is disabled. For information about split-tunnel VPN endpoints, see `Split-tunnel AWS Client VPN endpoint <https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html>`_ in the *AWS Client VPN Administrator Guide* .
        :param tag_specifications: The tags to apply to the Client VPN endpoint during creation.
        :param transport_protocol: The transport protocol to be used by the VPN session. Default value: ``udp``
        :param vpc_id: The ID of the VPC to associate with the Client VPN endpoint. If no security group IDs are specified in the request, the default security group for the VPC is applied.
        :param vpn_port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Valid Values: ``443`` | ``1194`` Default Value: ``443``
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1880bffa9253aaedfa6af6175da6262a96ea34dadf82dc678a1eef91cb7b92f0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnClientVpnEndpointProps(
            authentication_options=authentication_options,
            client_cidr_block=client_cidr_block,
            connection_log_options=connection_log_options,
            server_certificate_arn=server_certificate_arn,
            client_connect_options=client_connect_options,
            client_login_banner_options=client_login_banner_options,
            client_route_monitoring_options=client_route_monitoring_options,
            description=description,
            dns_servers=dns_servers,
            security_group_ids=security_group_ids,
            self_service_portal=self_service_portal,
            session_timeout_hours=session_timeout_hours,
            split_tunnel=split_tunnel,
            tag_specifications=tag_specifications,
            transport_protocol=transport_protocol,
            vpc_id=vpc_id,
            vpn_port=vpn_port,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6c918e848a5790bf428aae5434bdf054890599ff5e33a0c7aec91388a7d88962)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4840c2bcc0e38eb5b8ab1bf4318bcc826fafc75f0b1a0d4b4af2671fd548551b)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="authenticationOptions")
    def authentication_options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientAuthenticationRequestProperty"]]]:
        '''Information about the authentication method to be used to authenticate clients.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientAuthenticationRequestProperty"]]], jsii.get(self, "authenticationOptions"))

    @authentication_options.setter
    def authentication_options(
        self,
        value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientAuthenticationRequestProperty"]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8fd721536b7af569ca4dd0cf5d6d3e5a4af03f14f0a211dca122f2c1ac5297c8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "authenticationOptions", value)

    @builtins.property
    @jsii.member(jsii_name="clientCidrBlock")
    def client_cidr_block(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, from which to assign client IP addresses.'''
        return typing.cast(builtins.str, jsii.get(self, "clientCidrBlock"))

    @client_cidr_block.setter
    def client_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c82ca35d7edd1869a3d83867786684f955e85c4ac53303d02ebbdd382476bc11)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="connectionLogOptions")
    def connection_log_options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ConnectionLogOptionsProperty"]:
        '''Information about the client connection logging options.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ConnectionLogOptionsProperty"], jsii.get(self, "connectionLogOptions"))

    @connection_log_options.setter
    def connection_log_options(
        self,
        value: typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ConnectionLogOptionsProperty"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__18d2e85936305e18045946d27a2644a466c3e1398c55ace117c923d19e4e239f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connectionLogOptions", value)

    @builtins.property
    @jsii.member(jsii_name="serverCertificateArn")
    def server_certificate_arn(self) -> builtins.str:
        '''The ARN of the server certificate.'''
        return typing.cast(builtins.str, jsii.get(self, "serverCertificateArn"))

    @server_certificate_arn.setter
    def server_certificate_arn(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2bd127fecac421e3bc066a629699ad50c84a77153f1ec4f5626641e6e71005ba)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "serverCertificateArn", value)

    @builtins.property
    @jsii.member(jsii_name="clientConnectOptions")
    def client_connect_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientConnectOptionsProperty"]]:
        '''The options for managing connection authorization for new client connections.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientConnectOptionsProperty"]], jsii.get(self, "clientConnectOptions"))

    @client_connect_options.setter
    def client_connect_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientConnectOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ff43378f198f2e58416acaccf8cc15978b8057d3e692a315efe9a325e263a4f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientConnectOptions", value)

    @builtins.property
    @jsii.member(jsii_name="clientLoginBannerOptions")
    def client_login_banner_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty"]]:
        '''Options for enabling a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty"]], jsii.get(self, "clientLoginBannerOptions"))

    @client_login_banner_options.setter
    def client_login_banner_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__497c1bea9e9caa987aeafc2d4334f07cd2d9664a3f3cd38bebd5611705a992a0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientLoginBannerOptions", value)

    @builtins.property
    @jsii.member(jsii_name="clientRouteMonitoringOptions")
    def client_route_monitoring_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty"]]:
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty"]], jsii.get(self, "clientRouteMonitoringOptions"))

    @client_route_monitoring_options.setter
    def client_route_monitoring_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__256286aa73ef76d9e8c01586acd7784d241671a2785ad66bbabd4271eef9d823)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientRouteMonitoringOptions", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the Client VPN endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb1d5fb0102c1b6de24ad13acfc13837ec5422291e23048395fe03350aea2188)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="dnsServers")
    def dns_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Information about the DNS servers to be used for DNS resolution.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "dnsServers"))

    @dns_servers.setter
    def dns_servers(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ebcac79eb30395bbcc38271559390a74d75a7ae45dfe368c2cd3b996b81b462)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dnsServers", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIds")
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more security groups to apply to the target network.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroupIds"))

    @security_group_ids.setter
    def security_group_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__579de23f23e1dd217e8431defd11b303d19733349907433779f8a626aae9cde9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIds", value)

    @builtins.property
    @jsii.member(jsii_name="selfServicePortal")
    def self_service_portal(self) -> typing.Optional[builtins.str]:
        '''Specify whether to enable the self-service portal for the Client VPN endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "selfServicePortal"))

    @self_service_portal.setter
    def self_service_portal(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8906bf30210d5bc2dc8408899f5ca0117189261f028b77c92f7388e86156315c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "selfServicePortal", value)

    @builtins.property
    @jsii.member(jsii_name="sessionTimeoutHours")
    def session_timeout_hours(self) -> typing.Optional[jsii.Number]:
        '''The maximum VPN session duration time in hours.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "sessionTimeoutHours"))

    @session_timeout_hours.setter
    def session_timeout_hours(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__794dd5b3de3a1c6a9d4c9dab081dbf25f0c2c05274d74b3e4fc01f8b17001d25)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sessionTimeoutHours", value)

    @builtins.property
    @jsii.member(jsii_name="splitTunnel")
    def split_tunnel(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "splitTunnel"))

    @split_tunnel.setter
    def split_tunnel(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d96887217ae5515add2cb3a59126e1d0cd39a226e9816afa37568bc70cb2f61)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "splitTunnel", value)

    @builtins.property
    @jsii.member(jsii_name="tagSpecifications")
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.TagSpecificationProperty"]]]]:
        '''The tags to apply to the Client VPN endpoint during creation.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.TagSpecificationProperty"]]]], jsii.get(self, "tagSpecifications"))

    @tag_specifications.setter
    def tag_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.TagSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cc170770bc9adc8648a63b630961b275859df1f9019415667b679b2cf764d8eb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="transportProtocol")
    def transport_protocol(self) -> typing.Optional[builtins.str]:
        '''The transport protocol to be used by the VPN session.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "transportProtocol"))

    @transport_protocol.setter
    def transport_protocol(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7606d3932bdd042643cd05946ce9c33ae761b0b43aa601cec4d7639cdf467b12)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transportProtocol", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the VPC to associate with the Client VPN endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__10f3125d05aba06539b785430760a1829e6fb47f55d9a88648888bf1727da9f5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="vpnPort")
    def vpn_port(self) -> typing.Optional[jsii.Number]:
        '''The port number to assign to the Client VPN endpoint for TCP and UDP traffic.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "vpnPort"))

    @vpn_port.setter
    def vpn_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__662eb5a92b0bd04e8bb4b264778b748b7e43ac948946096053c568d8b911e105)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnPort", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "client_root_certificate_chain_arn": "clientRootCertificateChainArn",
        },
    )
    class CertificateAuthenticationRequestProperty:
        def __init__(self, *, client_root_certificate_chain_arn: builtins.str) -> None:
            '''Information about the client certificate to be used for authentication.

            :param client_root_certificate_chain_arn: The ARN of the client certificate. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-certificateauthenticationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                certificate_authentication_request_property = ec2.CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty(
                    client_root_certificate_chain_arn="clientRootCertificateChainArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__cc37b569930b5db9e1e89a2936bbf73c15c41b1fc566455e26a96a67b711362a)
                check_type(argname="argument client_root_certificate_chain_arn", value=client_root_certificate_chain_arn, expected_type=type_hints["client_root_certificate_chain_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "client_root_certificate_chain_arn": client_root_certificate_chain_arn,
            }

        @builtins.property
        def client_root_certificate_chain_arn(self) -> builtins.str:
            '''The ARN of the client certificate.

            The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-certificateauthenticationrequest.html#cfn-ec2-clientvpnendpoint-certificateauthenticationrequest-clientrootcertificatechainarn
            '''
            result = self._values.get("client_root_certificate_chain_arn")
            assert result is not None, "Required property 'client_root_certificate_chain_arn' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CertificateAuthenticationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.ClientAuthenticationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "type": "type",
            "active_directory": "activeDirectory",
            "federated_authentication": "federatedAuthentication",
            "mutual_authentication": "mutualAuthentication",
        },
    )
    class ClientAuthenticationRequestProperty:
        def __init__(
            self,
            *,
            type: builtins.str,
            active_directory: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            federated_authentication: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            mutual_authentication: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes the authentication method to be used by a Client VPN endpoint.

            For more information, see `Authentication <https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/authentication-authrization.html#client-authentication>`_ in the *AWS Client VPN Administrator Guide* .

            :param type: The type of client authentication to be used.
            :param active_directory: Information about the Active Directory to be used, if applicable. You must provide this information if *Type* is ``directory-service-authentication`` .
            :param federated_authentication: Information about the IAM SAML identity provider, if applicable.
            :param mutual_authentication: Information about the authentication certificates to be used, if applicable. You must provide this information if *Type* is ``certificate-authentication`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientauthenticationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                client_authentication_request_property = ec2.CfnClientVpnEndpoint.ClientAuthenticationRequestProperty(
                    type="type",
                
                    # the properties below are optional
                    active_directory=ec2.CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty(
                        directory_id="directoryId"
                    ),
                    federated_authentication=ec2.CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty(
                        saml_provider_arn="samlProviderArn",
                
                        # the properties below are optional
                        self_service_saml_provider_arn="selfServiceSamlProviderArn"
                    ),
                    mutual_authentication=ec2.CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty(
                        client_root_certificate_chain_arn="clientRootCertificateChainArn"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__93d4b5bf25c558dd4e4b4bbec8493db5e9a168f9b8327c99f3b48709b29f0305)
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
                check_type(argname="argument active_directory", value=active_directory, expected_type=type_hints["active_directory"])
                check_type(argname="argument federated_authentication", value=federated_authentication, expected_type=type_hints["federated_authentication"])
                check_type(argname="argument mutual_authentication", value=mutual_authentication, expected_type=type_hints["mutual_authentication"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "type": type,
            }
            if active_directory is not None:
                self._values["active_directory"] = active_directory
            if federated_authentication is not None:
                self._values["federated_authentication"] = federated_authentication
            if mutual_authentication is not None:
                self._values["mutual_authentication"] = mutual_authentication

        @builtins.property
        def type(self) -> builtins.str:
            '''The type of client authentication to be used.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientauthenticationrequest.html#cfn-ec2-clientvpnendpoint-clientauthenticationrequest-type
            '''
            result = self._values.get("type")
            assert result is not None, "Required property 'type' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def active_directory(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty"]]:
            '''Information about the Active Directory to be used, if applicable.

            You must provide this information if *Type* is ``directory-service-authentication`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientauthenticationrequest.html#cfn-ec2-clientvpnendpoint-clientauthenticationrequest-activedirectory
            '''
            result = self._values.get("active_directory")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty"]], result)

        @builtins.property
        def federated_authentication(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty"]]:
            '''Information about the IAM SAML identity provider, if applicable.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientauthenticationrequest.html#cfn-ec2-clientvpnendpoint-clientauthenticationrequest-federatedauthentication
            '''
            result = self._values.get("federated_authentication")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty"]], result)

        @builtins.property
        def mutual_authentication(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty"]]:
            '''Information about the authentication certificates to be used, if applicable.

            You must provide this information if *Type* is ``certificate-authentication`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientauthenticationrequest.html#cfn-ec2-clientvpnendpoint-clientauthenticationrequest-mutualauthentication
            '''
            result = self._values.get("mutual_authentication")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClientAuthenticationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.ClientConnectOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "enabled": "enabled",
            "lambda_function_arn": "lambdaFunctionArn",
        },
    )
    class ClientConnectOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
            lambda_function_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Indicates whether client connect options are enabled.

            The default is ``false`` (not enabled).

            :param enabled: Indicates whether client connect options are enabled. The default is ``false`` (not enabled).
            :param lambda_function_arn: The Amazon Resource Name (ARN) of the AWS Lambda function used for connection authorization.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientconnectoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                client_connect_options_property = ec2.CfnClientVpnEndpoint.ClientConnectOptionsProperty(
                    enabled=False,
                
                    # the properties below are optional
                    lambda_function_arn="lambdaFunctionArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c807bc6c81e334e361f85e32e4442141132b4ee3c4bacdaed8cf79b617caaa57)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
                check_type(argname="argument lambda_function_arn", value=lambda_function_arn, expected_type=type_hints["lambda_function_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "enabled": enabled,
            }
            if lambda_function_arn is not None:
                self._values["lambda_function_arn"] = lambda_function_arn

        @builtins.property
        def enabled(self) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Indicates whether client connect options are enabled.

            The default is ``false`` (not enabled).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientconnectoptions.html#cfn-ec2-clientvpnendpoint-clientconnectoptions-enabled
            '''
            result = self._values.get("enabled")
            assert result is not None, "Required property 'enabled' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def lambda_function_arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the AWS Lambda function used for connection authorization.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientconnectoptions.html#cfn-ec2-clientvpnendpoint-clientconnectoptions-lambdafunctionarn
            '''
            result = self._values.get("lambda_function_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClientConnectOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled", "banner_text": "bannerText"},
    )
    class ClientLoginBannerOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
            banner_text: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Options for enabling a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.

            :param enabled: Enable or disable a customizable text banner that will be displayed on AWS provided clients when a VPN session is established. Valid values: ``true | false`` Default value: ``false``
            :param banner_text: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientloginbanneroptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                client_login_banner_options_property = ec2.CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty(
                    enabled=False,
                
                    # the properties below are optional
                    banner_text="bannerText"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__907ff3a3bd097ac37a720bbc18cf4e29748beb226ddf13641e48350162da19d3)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
                check_type(argname="argument banner_text", value=banner_text, expected_type=type_hints["banner_text"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "enabled": enabled,
            }
            if banner_text is not None:
                self._values["banner_text"] = banner_text

        @builtins.property
        def enabled(self) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Enable or disable a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.

            Valid values: ``true | false``

            Default value: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientloginbanneroptions.html#cfn-ec2-clientvpnendpoint-clientloginbanneroptions-enabled
            '''
            result = self._values.get("enabled")
            assert result is not None, "Required property 'enabled' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def banner_text(self) -> typing.Optional[builtins.str]:
            '''Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established.

            UTF-8 encoded characters only. Maximum of 1400 characters.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientloginbanneroptions.html#cfn-ec2-clientvpnendpoint-clientloginbanneroptions-bannertext
            '''
            result = self._values.get("banner_text")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClientLoginBannerOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled"},
    )
    class ClientRouteMonitoringOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''
            :param enabled: 

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientroutemonitoringoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                client_route_monitoring_options_property = ec2.CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty(
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__a95e90764e53fffb06a3e0dcecbd41f642f3362128769eb65cf04e24be9cd71b)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''
            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-clientroutemonitoringoptions.html#cfn-ec2-clientvpnendpoint-clientroutemonitoringoptions-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClientRouteMonitoringOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.ConnectionLogOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "enabled": "enabled",
            "cloudwatch_log_group": "cloudwatchLogGroup",
            "cloudwatch_log_stream": "cloudwatchLogStream",
        },
    )
    class ConnectionLogOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
            cloudwatch_log_group: typing.Optional[builtins.str] = None,
            cloudwatch_log_stream: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the client connection logging options for the Client VPN endpoint.

            :param enabled: Indicates whether connection logging is enabled.
            :param cloudwatch_log_group: The name of the CloudWatch Logs log group. Required if connection logging is enabled.
            :param cloudwatch_log_stream: The name of the CloudWatch Logs log stream to which the connection data is published.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-connectionlogoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                connection_log_options_property = ec2.CfnClientVpnEndpoint.ConnectionLogOptionsProperty(
                    enabled=False,
                
                    # the properties below are optional
                    cloudwatch_log_group="cloudwatchLogGroup",
                    cloudwatch_log_stream="cloudwatchLogStream"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__2c142e5322bb8bda4ace9616736c0e12d7c7b9b219932b4168a975e68d0d9395)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
                check_type(argname="argument cloudwatch_log_group", value=cloudwatch_log_group, expected_type=type_hints["cloudwatch_log_group"])
                check_type(argname="argument cloudwatch_log_stream", value=cloudwatch_log_stream, expected_type=type_hints["cloudwatch_log_stream"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "enabled": enabled,
            }
            if cloudwatch_log_group is not None:
                self._values["cloudwatch_log_group"] = cloudwatch_log_group
            if cloudwatch_log_stream is not None:
                self._values["cloudwatch_log_stream"] = cloudwatch_log_stream

        @builtins.property
        def enabled(self) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Indicates whether connection logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-connectionlogoptions.html#cfn-ec2-clientvpnendpoint-connectionlogoptions-enabled
            '''
            result = self._values.get("enabled")
            assert result is not None, "Required property 'enabled' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def cloudwatch_log_group(self) -> typing.Optional[builtins.str]:
            '''The name of the CloudWatch Logs log group.

            Required if connection logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-connectionlogoptions.html#cfn-ec2-clientvpnendpoint-connectionlogoptions-cloudwatchloggroup
            '''
            result = self._values.get("cloudwatch_log_group")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cloudwatch_log_stream(self) -> typing.Optional[builtins.str]:
            '''The name of the CloudWatch Logs log stream to which the connection data is published.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-connectionlogoptions.html#cfn-ec2-clientvpnendpoint-connectionlogoptions-cloudwatchlogstream
            '''
            result = self._values.get("cloudwatch_log_stream")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ConnectionLogOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"directory_id": "directoryId"},
    )
    class DirectoryServiceAuthenticationRequestProperty:
        def __init__(self, *, directory_id: builtins.str) -> None:
            '''Describes the Active Directory to be used for client authentication.

            :param directory_id: The ID of the Active Directory to be used for authentication.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-directoryserviceauthenticationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                directory_service_authentication_request_property = ec2.CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty(
                    directory_id="directoryId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c6fc687dd9d11c39776770388c8bde0ccd238cd37eb50b3855604baa114f8fcc)
                check_type(argname="argument directory_id", value=directory_id, expected_type=type_hints["directory_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "directory_id": directory_id,
            }

        @builtins.property
        def directory_id(self) -> builtins.str:
            '''The ID of the Active Directory to be used for authentication.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-directoryserviceauthenticationrequest.html#cfn-ec2-clientvpnendpoint-directoryserviceauthenticationrequest-directoryid
            '''
            result = self._values.get("directory_id")
            assert result is not None, "Required property 'directory_id' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "DirectoryServiceAuthenticationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "saml_provider_arn": "samlProviderArn",
            "self_service_saml_provider_arn": "selfServiceSamlProviderArn",
        },
    )
    class FederatedAuthenticationRequestProperty:
        def __init__(
            self,
            *,
            saml_provider_arn: builtins.str,
            self_service_saml_provider_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The IAM SAML identity provider used for federated authentication.

            :param saml_provider_arn: The Amazon Resource Name (ARN) of the IAM SAML identity provider.
            :param self_service_saml_provider_arn: The Amazon Resource Name (ARN) of the IAM SAML identity provider for the self-service portal.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-federatedauthenticationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                federated_authentication_request_property = ec2.CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty(
                    saml_provider_arn="samlProviderArn",
                
                    # the properties below are optional
                    self_service_saml_provider_arn="selfServiceSamlProviderArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6d301df1b88110c542331637189053fa067891656efcdcce073dea638050e816)
                check_type(argname="argument saml_provider_arn", value=saml_provider_arn, expected_type=type_hints["saml_provider_arn"])
                check_type(argname="argument self_service_saml_provider_arn", value=self_service_saml_provider_arn, expected_type=type_hints["self_service_saml_provider_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "saml_provider_arn": saml_provider_arn,
            }
            if self_service_saml_provider_arn is not None:
                self._values["self_service_saml_provider_arn"] = self_service_saml_provider_arn

        @builtins.property
        def saml_provider_arn(self) -> builtins.str:
            '''The Amazon Resource Name (ARN) of the IAM SAML identity provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-federatedauthenticationrequest.html#cfn-ec2-clientvpnendpoint-federatedauthenticationrequest-samlproviderarn
            '''
            result = self._values.get("saml_provider_arn")
            assert result is not None, "Required property 'saml_provider_arn' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def self_service_saml_provider_arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the IAM SAML identity provider for the self-service portal.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-federatedauthenticationrequest.html#cfn-ec2-clientvpnendpoint-federatedauthenticationrequest-selfservicesamlproviderarn
            '''
            result = self._values.get("self_service_saml_provider_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FederatedAuthenticationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpoint.TagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class TagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: builtins.str,
            tags: typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]],
        ) -> None:
            '''The tags to apply to a resource when the resource is being created.

            When you specify a tag, you must specify the resource type to tag, otherwise the request will fail.
            .. epigraph::

               The ``Valid Values`` lists all the resource types that can be tagged. However, the action you're using might not support tagging all of these resource types. If you try to tag a resource type that is unsupported for the action you're using, you'll get an error.

            :param resource_type: The type of resource to tag.
            :param tags: The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-tagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                tag_specification_property = ec2.CfnClientVpnEndpoint.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__7fadda101a8454212efac8a224e66b4af09c2e630eb4772396408c19bf7444d1)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "resource_type": resource_type,
                "tags": tags,
            }

        @builtins.property
        def resource_type(self) -> builtins.str:
            '''The type of resource to tag.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-tagspecification.html#cfn-ec2-clientvpnendpoint-tagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            assert result is not None, "Required property 'resource_type' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def tags(self) -> typing.List[_CfnTag_f6864754]:
            '''The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-clientvpnendpoint-tagspecification.html#cfn-ec2-clientvpnendpoint-tagspecification-tags
            '''
            result = self._values.get("tags")
            assert result is not None, "Required property 'tags' is missing"
            return typing.cast(typing.List[_CfnTag_f6864754], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnEndpointProps",
    jsii_struct_bases=[],
    name_mapping={
        "authentication_options": "authenticationOptions",
        "client_cidr_block": "clientCidrBlock",
        "connection_log_options": "connectionLogOptions",
        "server_certificate_arn": "serverCertificateArn",
        "client_connect_options": "clientConnectOptions",
        "client_login_banner_options": "clientLoginBannerOptions",
        "client_route_monitoring_options": "clientRouteMonitoringOptions",
        "description": "description",
        "dns_servers": "dnsServers",
        "security_group_ids": "securityGroupIds",
        "self_service_portal": "selfServicePortal",
        "session_timeout_hours": "sessionTimeoutHours",
        "split_tunnel": "splitTunnel",
        "tag_specifications": "tagSpecifications",
        "transport_protocol": "transportProtocol",
        "vpc_id": "vpcId",
        "vpn_port": "vpnPort",
    },
)
class CfnClientVpnEndpointProps:
    def __init__(
        self,
        *,
        authentication_options: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
        client_cidr_block: builtins.str,
        connection_log_options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ConnectionLogOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
        server_certificate_arn: builtins.str,
        client_connect_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        client_login_banner_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        client_route_monitoring_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        self_service_portal: typing.Optional[builtins.str] = None,
        session_timeout_hours: typing.Optional[jsii.Number] = None,
        split_tunnel: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        transport_protocol: typing.Optional[builtins.str] = None,
        vpc_id: typing.Optional[builtins.str] = None,
        vpn_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnClientVpnEndpoint``.

        :param authentication_options: Information about the authentication method to be used to authenticate clients.
        :param client_cidr_block: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. The address range cannot be changed after the Client VPN endpoint has been created. Client CIDR range must have a size of at least /22 and must not be greater than /12.
        :param connection_log_options: Information about the client connection logging options. If you enable client connection logging, data about client connections is sent to a Cloudwatch Logs log stream. The following information is logged: - Client connection requests - Client connection results (successful and unsuccessful) - Reasons for unsuccessful client connection requests - Client connection termination time
        :param server_certificate_arn: The ARN of the server certificate. For more information, see the `AWS Certificate Manager User Guide <https://docs.aws.amazon.com/acm/latest/userguide/>`_ .
        :param client_connect_options: The options for managing connection authorization for new client connections.
        :param client_login_banner_options: Options for enabling a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.
        :param client_route_monitoring_options: 
        :param description: A brief description of the Client VPN endpoint.
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. If no DNS server is specified, the DNS address configured on the device is used for the DNS server.
        :param security_group_ids: The IDs of one or more security groups to apply to the target network. You must also specify the ID of the VPC that contains the security groups.
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default Value: ``enabled``
        :param session_timeout_hours: The maximum VPN session duration time in hours. Valid values: ``8 | 10 | 12 | 24`` Default value: ``24``
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. By default, split-tunnel on a VPN endpoint is disabled. For information about split-tunnel VPN endpoints, see `Split-tunnel AWS Client VPN endpoint <https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html>`_ in the *AWS Client VPN Administrator Guide* .
        :param tag_specifications: The tags to apply to the Client VPN endpoint during creation.
        :param transport_protocol: The transport protocol to be used by the VPN session. Default value: ``udp``
        :param vpc_id: The ID of the VPC to associate with the Client VPN endpoint. If no security group IDs are specified in the request, the default security group for the VPC is applied.
        :param vpn_port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Valid Values: ``443`` | ``1194`` Default Value: ``443``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_client_vpn_endpoint_props = ec2.CfnClientVpnEndpointProps(
                authentication_options=[ec2.CfnClientVpnEndpoint.ClientAuthenticationRequestProperty(
                    type="type",
            
                    # the properties below are optional
                    active_directory=ec2.CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty(
                        directory_id="directoryId"
                    ),
                    federated_authentication=ec2.CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty(
                        saml_provider_arn="samlProviderArn",
            
                        # the properties below are optional
                        self_service_saml_provider_arn="selfServiceSamlProviderArn"
                    ),
                    mutual_authentication=ec2.CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty(
                        client_root_certificate_chain_arn="clientRootCertificateChainArn"
                    )
                )],
                client_cidr_block="clientCidrBlock",
                connection_log_options=ec2.CfnClientVpnEndpoint.ConnectionLogOptionsProperty(
                    enabled=False,
            
                    # the properties below are optional
                    cloudwatch_log_group="cloudwatchLogGroup",
                    cloudwatch_log_stream="cloudwatchLogStream"
                ),
                server_certificate_arn="serverCertificateArn",
            
                # the properties below are optional
                client_connect_options=ec2.CfnClientVpnEndpoint.ClientConnectOptionsProperty(
                    enabled=False,
            
                    # the properties below are optional
                    lambda_function_arn="lambdaFunctionArn"
                ),
                client_login_banner_options=ec2.CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty(
                    enabled=False,
            
                    # the properties below are optional
                    banner_text="bannerText"
                ),
                client_route_monitoring_options=ec2.CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty(
                    enabled=False
                ),
                description="description",
                dns_servers=["dnsServers"],
                security_group_ids=["securityGroupIds"],
                self_service_portal="selfServicePortal",
                session_timeout_hours=123,
                split_tunnel=False,
                tag_specifications=[ec2.CfnClientVpnEndpoint.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )],
                transport_protocol="transportProtocol",
                vpc_id="vpcId",
                vpn_port=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__05994467e800c33b4a01e884b4b20bef2569d710f5dc323617cd814e50e5bdb5)
            check_type(argname="argument authentication_options", value=authentication_options, expected_type=type_hints["authentication_options"])
            check_type(argname="argument client_cidr_block", value=client_cidr_block, expected_type=type_hints["client_cidr_block"])
            check_type(argname="argument connection_log_options", value=connection_log_options, expected_type=type_hints["connection_log_options"])
            check_type(argname="argument server_certificate_arn", value=server_certificate_arn, expected_type=type_hints["server_certificate_arn"])
            check_type(argname="argument client_connect_options", value=client_connect_options, expected_type=type_hints["client_connect_options"])
            check_type(argname="argument client_login_banner_options", value=client_login_banner_options, expected_type=type_hints["client_login_banner_options"])
            check_type(argname="argument client_route_monitoring_options", value=client_route_monitoring_options, expected_type=type_hints["client_route_monitoring_options"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument dns_servers", value=dns_servers, expected_type=type_hints["dns_servers"])
            check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
            check_type(argname="argument self_service_portal", value=self_service_portal, expected_type=type_hints["self_service_portal"])
            check_type(argname="argument session_timeout_hours", value=session_timeout_hours, expected_type=type_hints["session_timeout_hours"])
            check_type(argname="argument split_tunnel", value=split_tunnel, expected_type=type_hints["split_tunnel"])
            check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
            check_type(argname="argument transport_protocol", value=transport_protocol, expected_type=type_hints["transport_protocol"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument vpn_port", value=vpn_port, expected_type=type_hints["vpn_port"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "authentication_options": authentication_options,
            "client_cidr_block": client_cidr_block,
            "connection_log_options": connection_log_options,
            "server_certificate_arn": server_certificate_arn,
        }
        if client_connect_options is not None:
            self._values["client_connect_options"] = client_connect_options
        if client_login_banner_options is not None:
            self._values["client_login_banner_options"] = client_login_banner_options
        if client_route_monitoring_options is not None:
            self._values["client_route_monitoring_options"] = client_route_monitoring_options
        if description is not None:
            self._values["description"] = description
        if dns_servers is not None:
            self._values["dns_servers"] = dns_servers
        if security_group_ids is not None:
            self._values["security_group_ids"] = security_group_ids
        if self_service_portal is not None:
            self._values["self_service_portal"] = self_service_portal
        if session_timeout_hours is not None:
            self._values["session_timeout_hours"] = session_timeout_hours
        if split_tunnel is not None:
            self._values["split_tunnel"] = split_tunnel
        if tag_specifications is not None:
            self._values["tag_specifications"] = tag_specifications
        if transport_protocol is not None:
            self._values["transport_protocol"] = transport_protocol
        if vpc_id is not None:
            self._values["vpc_id"] = vpc_id
        if vpn_port is not None:
            self._values["vpn_port"] = vpn_port

    @builtins.property
    def authentication_options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientAuthenticationRequestProperty]]]:
        '''Information about the authentication method to be used to authenticate clients.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-authenticationoptions
        '''
        result = self._values.get("authentication_options")
        assert result is not None, "Required property 'authentication_options' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientAuthenticationRequestProperty]]], result)

    @builtins.property
    def client_cidr_block(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, from which to assign client IP addresses.

        The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. The address range cannot be changed after the Client VPN endpoint has been created. Client CIDR range must have a size of at least /22 and must not be greater than /12.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-clientcidrblock
        '''
        result = self._values.get("client_cidr_block")
        assert result is not None, "Required property 'client_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def connection_log_options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ConnectionLogOptionsProperty]:
        '''Information about the client connection logging options.

        If you enable client connection logging, data about client connections is sent to a Cloudwatch Logs log stream. The following information is logged:

        - Client connection requests
        - Client connection results (successful and unsuccessful)
        - Reasons for unsuccessful client connection requests
        - Client connection termination time

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-connectionlogoptions
        '''
        result = self._values.get("connection_log_options")
        assert result is not None, "Required property 'connection_log_options' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ConnectionLogOptionsProperty], result)

    @builtins.property
    def server_certificate_arn(self) -> builtins.str:
        '''The ARN of the server certificate.

        For more information, see the `AWS Certificate Manager User Guide <https://docs.aws.amazon.com/acm/latest/userguide/>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-servercertificatearn
        '''
        result = self._values.get("server_certificate_arn")
        assert result is not None, "Required property 'server_certificate_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def client_connect_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientConnectOptionsProperty]]:
        '''The options for managing connection authorization for new client connections.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-clientconnectoptions
        '''
        result = self._values.get("client_connect_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientConnectOptionsProperty]], result)

    @builtins.property
    def client_login_banner_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty]]:
        '''Options for enabling a customizable text banner that will be displayed on AWS provided clients when a VPN session is established.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-clientloginbanneroptions
        '''
        result = self._values.get("client_login_banner_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty]], result)

    @builtins.property
    def client_route_monitoring_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty]]:
        '''
        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-clientroutemonitoringoptions
        '''
        result = self._values.get("client_route_monitoring_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty]], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the Client VPN endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dns_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Information about the DNS servers to be used for DNS resolution.

        A Client VPN endpoint can have up to two DNS servers. If no DNS server is specified, the DNS address configured on the device is used for the DNS server.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-dnsservers
        '''
        result = self._values.get("dns_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more security groups to apply to the target network.

        You must also specify the ID of the VPC that contains the security groups.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-securitygroupids
        '''
        result = self._values.get("security_group_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def self_service_portal(self) -> typing.Optional[builtins.str]:
        '''Specify whether to enable the self-service portal for the Client VPN endpoint.

        Default Value: ``enabled``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-selfserviceportal
        '''
        result = self._values.get("self_service_portal")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def session_timeout_hours(self) -> typing.Optional[jsii.Number]:
        '''The maximum VPN session duration time in hours.

        Valid values: ``8 | 10 | 12 | 24``

        Default value: ``24``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-sessiontimeouthours
        '''
        result = self._values.get("session_timeout_hours")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def split_tunnel(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint.

        By default, split-tunnel on a VPN endpoint is disabled.

        For information about split-tunnel VPN endpoints, see `Split-tunnel AWS Client VPN endpoint <https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html>`_ in the *AWS Client VPN Administrator Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-splittunnel
        '''
        result = self._values.get("split_tunnel")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.TagSpecificationProperty]]]]:
        '''The tags to apply to the Client VPN endpoint during creation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-tagspecifications
        '''
        result = self._values.get("tag_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.TagSpecificationProperty]]]], result)

    @builtins.property
    def transport_protocol(self) -> typing.Optional[builtins.str]:
        '''The transport protocol to be used by the VPN session.

        Default value: ``udp``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-transportprotocol
        '''
        result = self._values.get("transport_protocol")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the VPC to associate with the Client VPN endpoint.

        If no security group IDs are specified in the request, the default security group for the VPC is applied.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-vpcid
        '''
        result = self._values.get("vpc_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_port(self) -> typing.Optional[jsii.Number]:
        '''The port number to assign to the Client VPN endpoint for TCP and UDP traffic.

        Valid Values: ``443`` | ``1194``

        Default Value: ``443``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnendpoint.html#cfn-ec2-clientvpnendpoint-vpnport
        '''
        result = self._values.get("vpn_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnClientVpnEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnClientVpnRoute(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnRoute",
):
    '''Specifies a network route to add to a Client VPN endpoint.

    Each Client VPN endpoint has a route table that describes the available destination network routes. Each route in the route table specifies the path for traffic to specific resources or networks.

    A target network association must be created before you can specify a route. If you're setting up all the components of a Client VPN endpoint at the same time, you must use the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ to declare a dependency on the ``AWS::EC2::ClientVpnTargetNetworkAssociation`` resource.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html
    :cloudformationResource: AWS::EC2::ClientVpnRoute
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_client_vpn_route = ec2.CfnClientVpnRoute(self, "MyCfnClientVpnRoute",
            client_vpn_endpoint_id="clientVpnEndpointId",
            destination_cidr_block="destinationCidrBlock",
            target_vpc_subnet_id="targetVpcSubnetId",
        
            # the properties below are optional
            description="description"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        client_vpn_endpoint_id: builtins.str,
        destination_cidr_block: builtins.str,
        target_vpc_subnet_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint to which to add the route.
        :param destination_cidr_block: The IPv4 address range, in CIDR notation, of the route destination. For example:. - To add a route for Internet access, enter ``0.0.0.0/0`` - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target_vpc_subnet_id: The ID of the subnet through which you want to route traffic. The specified subnet must be an existing target network of the Client VPN endpoint. Alternatively, if you're adding a route for the local network, specify ``local`` .
        :param description: A brief description of the route.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3dfb737204851cc06c49c2c8a2089a474e3c7ab8c9522c2b17a1cda4e8d4e6d9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnClientVpnRouteProps(
            client_vpn_endpoint_id=client_vpn_endpoint_id,
            destination_cidr_block=destination_cidr_block,
            target_vpc_subnet_id=target_vpc_subnet_id,
            description=description,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ebdf42d79ea0b48b9768a7f69f6f849b67a9aceb079a45fd50f96be6327e5155)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3f633fca54521e752c1bc7455f2ac48bbea65e9b27b2cea6b3fcf87f8910a12)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="clientVpnEndpointId")
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint to which to add the route.'''
        return typing.cast(builtins.str, jsii.get(self, "clientVpnEndpointId"))

    @client_vpn_endpoint_id.setter
    def client_vpn_endpoint_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87c23fa81bc76240c6ce4c869a804c37228a002dc52b52a37dfc6164270825b1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientVpnEndpointId", value)

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the route destination.

        For example:.
        '''
        return typing.cast(builtins.str, jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e47d9f8cb47cf5a3263b2bb98b9ce1cc75c52af2f813f0966d8d270ea841ec3b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="targetVpcSubnetId")
    def target_vpc_subnet_id(self) -> builtins.str:
        '''The ID of the subnet through which you want to route traffic.'''
        return typing.cast(builtins.str, jsii.get(self, "targetVpcSubnetId"))

    @target_vpc_subnet_id.setter
    def target_vpc_subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__512be83797e2ddde08781d1160b36d983c2af081515532f8e3bb0689d136cfb4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "targetVpcSubnetId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the route.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b10f6f91046363ff96a4de67abb063cdae0418c01d141e45220d29a8a6c8d3a8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnRouteProps",
    jsii_struct_bases=[],
    name_mapping={
        "client_vpn_endpoint_id": "clientVpnEndpointId",
        "destination_cidr_block": "destinationCidrBlock",
        "target_vpc_subnet_id": "targetVpcSubnetId",
        "description": "description",
    },
)
class CfnClientVpnRouteProps:
    def __init__(
        self,
        *,
        client_vpn_endpoint_id: builtins.str,
        destination_cidr_block: builtins.str,
        target_vpc_subnet_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnClientVpnRoute``.

        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint to which to add the route.
        :param destination_cidr_block: The IPv4 address range, in CIDR notation, of the route destination. For example:. - To add a route for Internet access, enter ``0.0.0.0/0`` - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target_vpc_subnet_id: The ID of the subnet through which you want to route traffic. The specified subnet must be an existing target network of the Client VPN endpoint. Alternatively, if you're adding a route for the local network, specify ``local`` .
        :param description: A brief description of the route.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_client_vpn_route_props = ec2.CfnClientVpnRouteProps(
                client_vpn_endpoint_id="clientVpnEndpointId",
                destination_cidr_block="destinationCidrBlock",
                target_vpc_subnet_id="targetVpcSubnetId",
            
                # the properties below are optional
                description="description"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__04e293f5c6f16213a7dc895687cc68d3defb2606f9d9e24c82d8f28fab9a0c49)
            check_type(argname="argument client_vpn_endpoint_id", value=client_vpn_endpoint_id, expected_type=type_hints["client_vpn_endpoint_id"])
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument target_vpc_subnet_id", value=target_vpc_subnet_id, expected_type=type_hints["target_vpc_subnet_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "client_vpn_endpoint_id": client_vpn_endpoint_id,
            "destination_cidr_block": destination_cidr_block,
            "target_vpc_subnet_id": target_vpc_subnet_id,
        }
        if description is not None:
            self._values["description"] = description

    @builtins.property
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint to which to add the route.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html#cfn-ec2-clientvpnroute-clientvpnendpointid
        '''
        result = self._values.get("client_vpn_endpoint_id")
        assert result is not None, "Required property 'client_vpn_endpoint_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def destination_cidr_block(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the route destination. For example:.

        - To add a route for Internet access, enter ``0.0.0.0/0``
        - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range
        - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range
        - To add a route for the local network, enter the client CIDR range

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html#cfn-ec2-clientvpnroute-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        assert result is not None, "Required property 'destination_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def target_vpc_subnet_id(self) -> builtins.str:
        '''The ID of the subnet through which you want to route traffic.

        The specified subnet must be an existing target network of the Client VPN endpoint.

        Alternatively, if you're adding a route for the local network, specify ``local`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html#cfn-ec2-clientvpnroute-targetvpcsubnetid
        '''
        result = self._values.get("target_vpc_subnet_id")
        assert result is not None, "Required property 'target_vpc_subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the route.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html#cfn-ec2-clientvpnroute-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnClientVpnRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnClientVpnTargetNetworkAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnTargetNetworkAssociation",
):
    '''Specifies a target network to associate with a Client VPN endpoint.

    A target network is a subnet in a VPC. You can associate multiple subnets from the same VPC with a Client VPN endpoint. You can associate only one subnet in each Availability Zone. We recommend that you associate at least two subnets to provide Availability Zone redundancy.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpntargetnetworkassociation.html
    :cloudformationResource: AWS::EC2::ClientVpnTargetNetworkAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_client_vpn_target_network_association = ec2.CfnClientVpnTargetNetworkAssociation(self, "MyCfnClientVpnTargetNetworkAssociation",
            client_vpn_endpoint_id="clientVpnEndpointId",
            subnet_id="subnetId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        client_vpn_endpoint_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint.
        :param subnet_id: The ID of the subnet to associate with the Client VPN endpoint.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3246cdc0c4c45c3bb7ca145721849485de3058412b28e18e6a2521dee9feba7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnClientVpnTargetNetworkAssociationProps(
            client_vpn_endpoint_id=client_vpn_endpoint_id, subnet_id=subnet_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__328449dbe5f58a7132b6b6b1ba468f97ad09c68f19c7763fd188cb55dd0a50c3)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ce31eae78612f60b70ab52b2bb1a8bfb8da40aed559073873834454e4009da2)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="clientVpnEndpointId")
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "clientVpnEndpointId"))

    @client_vpn_endpoint_id.setter
    def client_vpn_endpoint_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__256c01852f9be0828ae3a474428434d9bcf06b1f2f38dd2cf5ff3440f4f4a5c4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientVpnEndpointId", value)

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet to associate with the Client VPN endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74bdd32493a6798a704c13cb4090daafbc17fc71b0f7e4b1dd8a078962344e35)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnClientVpnTargetNetworkAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "client_vpn_endpoint_id": "clientVpnEndpointId",
        "subnet_id": "subnetId",
    },
)
class CfnClientVpnTargetNetworkAssociationProps:
    def __init__(
        self,
        *,
        client_vpn_endpoint_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnClientVpnTargetNetworkAssociation``.

        :param client_vpn_endpoint_id: The ID of the Client VPN endpoint.
        :param subnet_id: The ID of the subnet to associate with the Client VPN endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpntargetnetworkassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_client_vpn_target_network_association_props = ec2.CfnClientVpnTargetNetworkAssociationProps(
                client_vpn_endpoint_id="clientVpnEndpointId",
                subnet_id="subnetId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__121d2c21f06ef1b4efdedfd8846bc605f91f3db0cc9c2844409f378474c9b397)
            check_type(argname="argument client_vpn_endpoint_id", value=client_vpn_endpoint_id, expected_type=type_hints["client_vpn_endpoint_id"])
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "client_vpn_endpoint_id": client_vpn_endpoint_id,
            "subnet_id": subnet_id,
        }

    @builtins.property
    def client_vpn_endpoint_id(self) -> builtins.str:
        '''The ID of the Client VPN endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpntargetnetworkassociation.html#cfn-ec2-clientvpntargetnetworkassociation-clientvpnendpointid
        '''
        result = self._values.get("client_vpn_endpoint_id")
        assert result is not None, "Required property 'client_vpn_endpoint_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet to associate with the Client VPN endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpntargetnetworkassociation.html#cfn-ec2-clientvpntargetnetworkassociation-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnClientVpnTargetNetworkAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnCustomerGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnCustomerGateway",
):
    '''Specifies a customer gateway.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html
    :cloudformationResource: AWS::EC2::CustomerGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_customer_gateway = ec2.CfnCustomerGateway(self, "MyCfnCustomerGateway",
            bgp_asn=123,
            ip_address="ipAddress",
            type="type",
        
            # the properties below are optional
            device_name="deviceName",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        bgp_asn: jsii.Number,
        ip_address: builtins.str,
        type: builtins.str,
        device_name: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param bgp_asn: For devices that support BGP, the customer gateway's BGP ASN. Default: 65000 Default: - 65000
        :param ip_address: IPv4 address for the customer gateway device's outside interface. The address must be static.
        :param type: The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).
        :param device_name: The name of customer gateway device.
        :param tags: One or more tags for the customer gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__16b41182e007e05b84fd0c97afc1e26001e78a56de2eb5b10c9f809de0654b0d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnCustomerGatewayProps(
            bgp_asn=bgp_asn,
            ip_address=ip_address,
            type=type,
            device_name=device_name,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce54eac1ec957fc55ffb27a654680402c3468f669a41d23ab734690d410698df)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a44104c4ad329cfdabba2866cf426d821fa85ba6f3aa04801988c746bd8ddad9)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCustomerGatewayId")
    def attr_customer_gateway_id(self) -> builtins.str:
        '''The ID of the customer gateway.

        :cloudformationAttribute: CustomerGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCustomerGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="bgpAsn")
    def bgp_asn(self) -> jsii.Number:
        '''For devices that support BGP, the customer gateway's BGP ASN.'''
        return typing.cast(jsii.Number, jsii.get(self, "bgpAsn"))

    @bgp_asn.setter
    def bgp_asn(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84dfb7d1775bd2bb124f990570c9a2ef23fafd01744cfe248fcb360562f57ca9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "bgpAsn", value)

    @builtins.property
    @jsii.member(jsii_name="ipAddress")
    def ip_address(self) -> builtins.str:
        '''IPv4 address for the customer gateway device's outside interface.'''
        return typing.cast(builtins.str, jsii.get(self, "ipAddress"))

    @ip_address.setter
    def ip_address(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a312c99e6832f0396cbd7c4d05fbab836db0503cf37ecee5f1f64bd213516c2e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipAddress", value)

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

    @type.setter
    def type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae973d5ca9904c069d03cbf10a1e3fdf7736cc00ca43663eb07598f97c4e5771)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value)

    @builtins.property
    @jsii.member(jsii_name="deviceName")
    def device_name(self) -> typing.Optional[builtins.str]:
        '''The name of customer gateway device.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deviceName"))

    @device_name.setter
    def device_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71d74664cf79e34328f5f6958fdd674c45b2780c9910dd252b7c5e9caba963f0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deviceName", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''One or more tags for the customer gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__05a111d13df5583de4721245805f1cb23e3c81e0e12774d2a044cf75bba55873)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnCustomerGatewayProps",
    jsii_struct_bases=[],
    name_mapping={
        "bgp_asn": "bgpAsn",
        "ip_address": "ipAddress",
        "type": "type",
        "device_name": "deviceName",
        "tags": "tags",
    },
)
class CfnCustomerGatewayProps:
    def __init__(
        self,
        *,
        bgp_asn: jsii.Number,
        ip_address: builtins.str,
        type: builtins.str,
        device_name: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnCustomerGateway``.

        :param bgp_asn: For devices that support BGP, the customer gateway's BGP ASN. Default: 65000 Default: - 65000
        :param ip_address: IPv4 address for the customer gateway device's outside interface. The address must be static.
        :param type: The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).
        :param device_name: The name of customer gateway device.
        :param tags: One or more tags for the customer gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_customer_gateway_props = ec2.CfnCustomerGatewayProps(
                bgp_asn=123,
                ip_address="ipAddress",
                type="type",
            
                # the properties below are optional
                device_name="deviceName",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b0ef9a2e3e2b6937b21db500a1cd795126e924d9b920931a413ecdb668bfc7ec)
            check_type(argname="argument bgp_asn", value=bgp_asn, expected_type=type_hints["bgp_asn"])
            check_type(argname="argument ip_address", value=ip_address, expected_type=type_hints["ip_address"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bgp_asn": bgp_asn,
            "ip_address": ip_address,
            "type": type,
        }
        if device_name is not None:
            self._values["device_name"] = device_name
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def bgp_asn(self) -> jsii.Number:
        '''For devices that support BGP, the customer gateway's BGP ASN.

        Default: 65000

        :default: - 65000

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-bgpasn
        '''
        result = self._values.get("bgp_asn")
        assert result is not None, "Required property 'bgp_asn' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def ip_address(self) -> builtins.str:
        '''IPv4 address for the customer gateway device's outside interface.

        The address must be static.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-ipaddress
        '''
        result = self._values.get("ip_address")
        assert result is not None, "Required property 'ip_address' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def type(self) -> builtins.str:
        '''The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-type
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def device_name(self) -> typing.Optional[builtins.str]:
        '''The name of customer gateway device.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-devicename
        '''
        result = self._values.get("device_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''One or more tags for the customer gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnCustomerGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnDHCPOptions(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnDHCPOptions",
):
    '''Specifies a set of DHCP options for your VPC.

    You must specify at least one of the following properties: ``DomainNameServers`` , ``NetbiosNameServers`` , ``NtpServers`` . If you specify ``NetbiosNameServers`` , you must specify ``NetbiosNodeType`` .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html
    :cloudformationResource: AWS::EC2::DHCPOptions
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_dHCPOptions = ec2.CfnDHCPOptions(self, "MyCfnDHCPOptions",
            domain_name="domainName",
            domain_name_servers=["domainNameServers"],
            netbios_name_servers=["netbiosNameServers"],
            netbios_node_type=123,
            ntp_servers=["ntpServers"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        domain_name: typing.Optional[builtins.str] = None,
        domain_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        netbios_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        netbios_node_type: typing.Optional[jsii.Number] = None,
        ntp_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param domain_name: This value is used to complete unqualified DNS hostnames. If you're using AmazonProvidedDNS in ``us-east-1`` , specify ``ec2.internal`` . If you're using AmazonProvidedDNS in another Region, specify *region* . ``compute.internal`` (for example, ``ap-northeast-1.compute.internal`` ). Otherwise, specify a domain name (for example, *MyCompany.com* ).
        :param domain_name_servers: The IPv4 addresses of up to four domain name servers, or ``AmazonProvidedDNS`` . The default is ``AmazonProvidedDNS`` . To have your instance receive a custom DNS hostname as specified in ``DomainName`` , you must set this property to a custom DNS server.
        :param netbios_name_servers: The IPv4 addresses of up to four NetBIOS name servers.
        :param netbios_node_type: The NetBIOS node type (1, 2, 4, or 8). We recommend that you specify 2 (broadcast and multicast are not currently supported).
        :param ntp_servers: The IPv4 addresses of up to four Network Time Protocol (NTP) servers.
        :param tags: Any tags assigned to the DHCP options set.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f22238da23e1a95528fc55d3e3a28b661b69a5dfe2d1e64620bef1ebd86deca)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnDHCPOptionsProps(
            domain_name=domain_name,
            domain_name_servers=domain_name_servers,
            netbios_name_servers=netbios_name_servers,
            netbios_node_type=netbios_node_type,
            ntp_servers=ntp_servers,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4bd34186ec5701fad199396bd872adb91c15f71647beefe007bb9dbafe17d86b)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c4b6b354957e45d57a7d74c91d58645803e6d3b3dc74c069422742dd52f73de0)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrDhcpOptionsId")
    def attr_dhcp_options_id(self) -> builtins.str:
        '''The ID of the DHCP options set.

        :cloudformationAttribute: DhcpOptionsId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDhcpOptionsId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="domainName")
    def domain_name(self) -> typing.Optional[builtins.str]:
        '''This value is used to complete unqualified DNS hostnames.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "domainName"))

    @domain_name.setter
    def domain_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3ef924b0a20b9413b973ce7cba216c31e794568c9f99a083b994d3e69ebb3c5e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "domainName", value)

    @builtins.property
    @jsii.member(jsii_name="domainNameServers")
    def domain_name_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four domain name servers, or ``AmazonProvidedDNS`` .'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "domainNameServers"))

    @domain_name_servers.setter
    def domain_name_servers(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9ee8e87c9581893159e005c5c7c786324d9f9c9a41ba0af4f72aedd3a9903ae)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "domainNameServers", value)

    @builtins.property
    @jsii.member(jsii_name="netbiosNameServers")
    def netbios_name_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four NetBIOS name servers.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "netbiosNameServers"))

    @netbios_name_servers.setter
    def netbios_name_servers(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3b8e4bd8f79a27f01b9c18995f6a45e13c80f3ff9f392b3c558b6cc5a5e5dba)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "netbiosNameServers", value)

    @builtins.property
    @jsii.member(jsii_name="netbiosNodeType")
    def netbios_node_type(self) -> typing.Optional[jsii.Number]:
        '''The NetBIOS node type (1, 2, 4, or 8).'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "netbiosNodeType"))

    @netbios_node_type.setter
    def netbios_node_type(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72bd8121cf33b33a52103c326c339f9ce10fbb12df0d71f411557aa642a9c385)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "netbiosNodeType", value)

    @builtins.property
    @jsii.member(jsii_name="ntpServers")
    def ntp_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four Network Time Protocol (NTP) servers.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ntpServers"))

    @ntp_servers.setter
    def ntp_servers(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__183fd1ef6a4ee905fe372ccc2f27b5ba3a48f856c21c3c678eb1b4db43bd1ab9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ntpServers", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the DHCP options set.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f4c459d5f98dbe6bf3fd3f9f7fca2823e7ee9510398ee1206c9aa28765f1d61c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnDHCPOptionsProps",
    jsii_struct_bases=[],
    name_mapping={
        "domain_name": "domainName",
        "domain_name_servers": "domainNameServers",
        "netbios_name_servers": "netbiosNameServers",
        "netbios_node_type": "netbiosNodeType",
        "ntp_servers": "ntpServers",
        "tags": "tags",
    },
)
class CfnDHCPOptionsProps:
    def __init__(
        self,
        *,
        domain_name: typing.Optional[builtins.str] = None,
        domain_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        netbios_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        netbios_node_type: typing.Optional[jsii.Number] = None,
        ntp_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnDHCPOptions``.

        :param domain_name: This value is used to complete unqualified DNS hostnames. If you're using AmazonProvidedDNS in ``us-east-1`` , specify ``ec2.internal`` . If you're using AmazonProvidedDNS in another Region, specify *region* . ``compute.internal`` (for example, ``ap-northeast-1.compute.internal`` ). Otherwise, specify a domain name (for example, *MyCompany.com* ).
        :param domain_name_servers: The IPv4 addresses of up to four domain name servers, or ``AmazonProvidedDNS`` . The default is ``AmazonProvidedDNS`` . To have your instance receive a custom DNS hostname as specified in ``DomainName`` , you must set this property to a custom DNS server.
        :param netbios_name_servers: The IPv4 addresses of up to four NetBIOS name servers.
        :param netbios_node_type: The NetBIOS node type (1, 2, 4, or 8). We recommend that you specify 2 (broadcast and multicast are not currently supported).
        :param ntp_servers: The IPv4 addresses of up to four Network Time Protocol (NTP) servers.
        :param tags: Any tags assigned to the DHCP options set.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_dHCPOptions_props = ec2.CfnDHCPOptionsProps(
                domain_name="domainName",
                domain_name_servers=["domainNameServers"],
                netbios_name_servers=["netbiosNameServers"],
                netbios_node_type=123,
                ntp_servers=["ntpServers"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__569097ad87e4dddbcfaee4fb50fc7ddb345c4f97ae82fcf897497039e7f81a38)
            check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
            check_type(argname="argument domain_name_servers", value=domain_name_servers, expected_type=type_hints["domain_name_servers"])
            check_type(argname="argument netbios_name_servers", value=netbios_name_servers, expected_type=type_hints["netbios_name_servers"])
            check_type(argname="argument netbios_node_type", value=netbios_node_type, expected_type=type_hints["netbios_node_type"])
            check_type(argname="argument ntp_servers", value=ntp_servers, expected_type=type_hints["ntp_servers"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if domain_name is not None:
            self._values["domain_name"] = domain_name
        if domain_name_servers is not None:
            self._values["domain_name_servers"] = domain_name_servers
        if netbios_name_servers is not None:
            self._values["netbios_name_servers"] = netbios_name_servers
        if netbios_node_type is not None:
            self._values["netbios_node_type"] = netbios_node_type
        if ntp_servers is not None:
            self._values["ntp_servers"] = ntp_servers
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def domain_name(self) -> typing.Optional[builtins.str]:
        '''This value is used to complete unqualified DNS hostnames.

        If you're using AmazonProvidedDNS in ``us-east-1`` , specify ``ec2.internal`` . If you're using AmazonProvidedDNS in another Region, specify *region* . ``compute.internal`` (for example, ``ap-northeast-1.compute.internal`` ). Otherwise, specify a domain name (for example, *MyCompany.com* ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-domainname
        '''
        result = self._values.get("domain_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def domain_name_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four domain name servers, or ``AmazonProvidedDNS`` .

        The default is ``AmazonProvidedDNS`` . To have your instance receive a custom DNS hostname as specified in ``DomainName`` , you must set this property to a custom DNS server.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-domainnameservers
        '''
        result = self._values.get("domain_name_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def netbios_name_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four NetBIOS name servers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-netbiosnameservers
        '''
        result = self._values.get("netbios_name_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def netbios_node_type(self) -> typing.Optional[jsii.Number]:
        '''The NetBIOS node type (1, 2, 4, or 8).

        We recommend that you specify 2 (broadcast and multicast are not currently supported).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-netbiosnodetype
        '''
        result = self._values.get("netbios_node_type")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ntp_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv4 addresses of up to four Network Time Protocol (NTP) servers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-ntpservers
        '''
        result = self._values.get("ntp_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the DHCP options set.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcpoptions.html#cfn-ec2-dhcpoptions-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnDHCPOptionsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnEC2Fleet(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet",
):
    '''Specifies the configuration information to launch a fleet--or group--of instances.

    An EC2 Fleet can launch multiple instance types across multiple Availability Zones, using the On-Demand Instance, Reserved Instance, and Spot Instance purchasing models together. Using EC2 Fleet, you can define separate On-Demand and Spot capacity targets, specify the instance types that work best for your applications, and specify how Amazon EC2 should distribute your fleet capacity within each purchasing model. For more information, see `Launching an EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html
    :cloudformationResource: AWS::EC2::EC2Fleet
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_eC2_fleet = ec2.CfnEC2Fleet(self, "MyCfnEC2Fleet",
            launch_template_configs=[ec2.CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty(
                launch_template_specification=ec2.CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty(
                    version="version",
        
                    # the properties below are optional
                    launch_template_id="launchTemplateId",
                    launch_template_name="launchTemplateName"
                ),
                overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                    availability_zone="availabilityZone",
                    instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                        accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        memory_gi_bPer_vCpu=ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    max_price="maxPrice",
                    placement=ec2.CfnEC2Fleet.PlacementProperty(
                        affinity="affinity",
                        availability_zone="availabilityZone",
                        group_name="groupName",
                        host_id="hostId",
                        host_resource_group_arn="hostResourceGroupArn",
                        partition_number=123,
                        spread_domain="spreadDomain",
                        tenancy="tenancy"
                    ),
                    priority=123,
                    subnet_id="subnetId",
                    weighted_capacity=123
                )]
            )],
            target_capacity_specification=ec2.CfnEC2Fleet.TargetCapacitySpecificationRequestProperty(
                total_target_capacity=123,
        
                # the properties below are optional
                default_target_capacity_type="defaultTargetCapacityType",
                on_demand_target_capacity=123,
                spot_target_capacity=123,
                target_capacity_unit_type="targetCapacityUnitType"
            ),
        
            # the properties below are optional
            context="context",
            excess_capacity_termination_policy="excessCapacityTerminationPolicy",
            on_demand_options=ec2.CfnEC2Fleet.OnDemandOptionsRequestProperty(
                allocation_strategy="allocationStrategy",
                capacity_reservation_options=ec2.CfnEC2Fleet.CapacityReservationOptionsRequestProperty(
                    usage_strategy="usageStrategy"
                ),
                max_total_price="maxTotalPrice",
                min_target_capacity=123,
                single_availability_zone=False,
                single_instance_type=False
            ),
            replace_unhealthy_instances=False,
            spot_options=ec2.CfnEC2Fleet.SpotOptionsRequestProperty(
                allocation_strategy="allocationStrategy",
                instance_interruption_behavior="instanceInterruptionBehavior",
                instance_pools_to_use_count=123,
                maintenance_strategies=ec2.CfnEC2Fleet.MaintenanceStrategiesProperty(
                    capacity_rebalance=ec2.CfnEC2Fleet.CapacityRebalanceProperty(
                        replacement_strategy="replacementStrategy",
                        termination_delay=123
                    )
                ),
                max_total_price="maxTotalPrice",
                min_target_capacity=123,
                single_availability_zone=False,
                single_instance_type=False
            ),
            tag_specifications=[ec2.CfnEC2Fleet.TagSpecificationProperty(
                resource_type="resourceType",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )],
            terminate_instances_with_expiration=False,
            type="type",
            valid_from="validFrom",
            valid_until="validUntil"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        launch_template_configs: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty", typing.Dict[builtins.str, typing.Any]]]]],
        target_capacity_specification: typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.TargetCapacitySpecificationRequestProperty", typing.Dict[builtins.str, typing.Any]]],
        context: typing.Optional[builtins.str] = None,
        excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
        on_demand_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.OnDemandOptionsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.SpotOptionsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.TagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        type: typing.Optional[builtins.str] = None,
        valid_from: typing.Optional[builtins.str] = None,
        valid_until: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param launch_template_configs: The configuration for the EC2 Fleet.
        :param target_capacity_specification: The number of units to request.
        :param context: Reserved.
        :param excess_capacity_termination_policy: Indicates whether running instances should be terminated if the total target capacity of the EC2 Fleet is decreased below the current size of the EC2 Fleet. Supported only for fleets of type ``maintain`` .
        :param on_demand_options: Describes the configuration of On-Demand Instances in an EC2 Fleet.
        :param replace_unhealthy_instances: Indicates whether EC2 Fleet should replace unhealthy Spot Instances. Supported only for fleets of type ``maintain`` . For more information, see `EC2 Fleet health checks <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks>`_ in the *Amazon EC2 User Guide* .
        :param spot_options: Describes the configuration of Spot Instances in an EC2 Fleet.
        :param tag_specifications: The key-value pair for tagging the EC2 Fleet request on creation. For more information, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ . If the fleet type is ``instant`` , specify a resource type of ``fleet`` to tag the fleet or ``instance`` to tag the instances at launch. If the fleet type is ``maintain`` or ``request`` , specify a resource type of ``fleet`` to tag the fleet. You cannot specify a resource type of ``instance`` . To tag instances at launch, specify the tags in a `launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ .
        :param terminate_instances_with_expiration: Indicates whether running instances should be terminated when the EC2 Fleet expires.
        :param type: The fleet type. The default value is ``maintain`` . - ``maintain`` - The EC2 Fleet places an asynchronous request for your desired capacity, and continues to maintain your desired Spot capacity by replenishing interrupted Spot Instances. - ``request`` - The EC2 Fleet places an asynchronous one-time request for your desired capacity, but does submit Spot requests in alternative capacity pools if Spot capacity is unavailable, and does not maintain Spot capacity if Spot Instances are interrupted. - ``instant`` - The EC2 Fleet places a synchronous one-time request for your desired capacity, and returns errors for any instances that could not be launched. For more information, see `EC2 Fleet request types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html>`_ in the *Amazon EC2 User Guide* .
        :param valid_from: The start date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). The default is to start fulfilling the request immediately.
        :param valid_until: The end date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). At this point, no new EC2 Fleet requests are placed or able to fulfill the request. If no value is specified, the request remains until you cancel it.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b04bc874649f768ee829fef298c1c886ebb6fc5aa454a0c698e17c25fc9b40f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnEC2FleetProps(
            launch_template_configs=launch_template_configs,
            target_capacity_specification=target_capacity_specification,
            context=context,
            excess_capacity_termination_policy=excess_capacity_termination_policy,
            on_demand_options=on_demand_options,
            replace_unhealthy_instances=replace_unhealthy_instances,
            spot_options=spot_options,
            tag_specifications=tag_specifications,
            terminate_instances_with_expiration=terminate_instances_with_expiration,
            type=type,
            valid_from=valid_from,
            valid_until=valid_until,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba2b8151d12fc4a02b9b697317595ccdcf5010cff290619525b157c76a9376e5)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__232ae85cfe3baeed9d41ac592afd4aeecf1a0032e258e71efca09cf806f2edcd)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrFleetId")
    def attr_fleet_id(self) -> builtins.str:
        '''The ID of the EC2 Fleet.

        :cloudformationAttribute: FleetId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrFleetId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateConfigs")
    def launch_template_configs(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty"]]]:
        '''The configuration for the EC2 Fleet.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty"]]], jsii.get(self, "launchTemplateConfigs"))

    @launch_template_configs.setter
    def launch_template_configs(
        self,
        value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty"]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11e66fc2296b61712f860ba32f7e4f6bae1d4caa8477ebd1d0e90496b03d47cb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "launchTemplateConfigs", value)

    @builtins.property
    @jsii.member(jsii_name="targetCapacitySpecification")
    def target_capacity_specification(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TargetCapacitySpecificationRequestProperty"]:
        '''The number of units to request.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TargetCapacitySpecificationRequestProperty"], jsii.get(self, "targetCapacitySpecification"))

    @target_capacity_specification.setter
    def target_capacity_specification(
        self,
        value: typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TargetCapacitySpecificationRequestProperty"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__308e9c06cb8e557e27da19507947b7edd3a3aadc38cdcddcdcc835402d1fdce7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "targetCapacitySpecification", value)

    @builtins.property
    @jsii.member(jsii_name="context")
    def context(self) -> typing.Optional[builtins.str]:
        '''Reserved.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "context"))

    @context.setter
    def context(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14055459b56a2936b7e5b3328bd76b98c965834cbec37d83a630495b8e9a8de1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "context", value)

    @builtins.property
    @jsii.member(jsii_name="excessCapacityTerminationPolicy")
    def excess_capacity_termination_policy(self) -> typing.Optional[builtins.str]:
        '''Indicates whether running instances should be terminated if the total target capacity of the EC2 Fleet is decreased below the current size of the EC2 Fleet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "excessCapacityTerminationPolicy"))

    @excess_capacity_termination_policy.setter
    def excess_capacity_termination_policy(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76724f7a5d1a753ad3d973f4e918523326a8dd12f7c437da5af31418195c7222)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "excessCapacityTerminationPolicy", value)

    @builtins.property
    @jsii.member(jsii_name="onDemandOptions")
    def on_demand_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.OnDemandOptionsRequestProperty"]]:
        '''Describes the configuration of On-Demand Instances in an EC2 Fleet.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.OnDemandOptionsRequestProperty"]], jsii.get(self, "onDemandOptions"))

    @on_demand_options.setter
    def on_demand_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.OnDemandOptionsRequestProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__387749e6f1f8ee96abed2de0d2312d91522d94f22e7c4625726360add11b93e4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "onDemandOptions", value)

    @builtins.property
    @jsii.member(jsii_name="replaceUnhealthyInstances")
    def replace_unhealthy_instances(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether EC2 Fleet should replace unhealthy Spot Instances.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "replaceUnhealthyInstances"))

    @replace_unhealthy_instances.setter
    def replace_unhealthy_instances(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__123332aa6b3b1e5b8f117ed3c89fbd1dc4fd57833234901707c819d14f66fe50)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "replaceUnhealthyInstances", value)

    @builtins.property
    @jsii.member(jsii_name="spotOptions")
    def spot_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.SpotOptionsRequestProperty"]]:
        '''Describes the configuration of Spot Instances in an EC2 Fleet.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.SpotOptionsRequestProperty"]], jsii.get(self, "spotOptions"))

    @spot_options.setter
    def spot_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.SpotOptionsRequestProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f056b97eccf2fbd77e6683adf7ef1aeb7b2afb2329fde0d2d6cfb1b273233bea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "spotOptions", value)

    @builtins.property
    @jsii.member(jsii_name="tagSpecifications")
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TagSpecificationProperty"]]]]:
        '''The key-value pair for tagging the EC2 Fleet request on creation.

        For more information, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ .
        '''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TagSpecificationProperty"]]]], jsii.get(self, "tagSpecifications"))

    @tag_specifications.setter
    def tag_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TagSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bece0741240e27126cb8a337d5fce1c6a45094b66f86472a241f9f7432e40a77)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="terminateInstancesWithExpiration")
    def terminate_instances_with_expiration(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether running instances should be terminated when the EC2 Fleet expires.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "terminateInstancesWithExpiration"))

    @terminate_instances_with_expiration.setter
    def terminate_instances_with_expiration(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0bd5baf142838966e793088318ff6c3b289335c1b15d0d9e87f74507d42d74df)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "terminateInstancesWithExpiration", value)

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> typing.Optional[builtins.str]:
        '''The fleet type.

        The default value is ``maintain`` .
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "type"))

    @type.setter
    def type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__59a50ca71a49c9d182b71322c445a4ba7d65a775570ca036914db2bb21276e74)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value)

    @builtins.property
    @jsii.member(jsii_name="validFrom")
    def valid_from(self) -> typing.Optional[builtins.str]:
        '''The start date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "validFrom"))

    @valid_from.setter
    def valid_from(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0dbca3955ea50bceaf0d75c83c574fa2b09d61b437759776878b29bf18cf1db8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "validFrom", value)

    @builtins.property
    @jsii.member(jsii_name="validUntil")
    def valid_until(self) -> typing.Optional[builtins.str]:
        '''The end date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "validUntil"))

    @valid_until.setter
    def valid_until(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d545dba13e879cf198f83427ce9f9f5071d32955fc00fa93ec5feaa00d5a36c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "validUntil", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.AcceleratorCountRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorCountRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            :param max: The maximum number of accelerators. To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .
            :param min: The minimum number of accelerators. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratorcountrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_count_request_property = ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__bc7b29adcb33628864e03a448dfeb55fe20e548d25b6d9dcc6fabe20e73cfe20)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of accelerators.

            To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratorcountrequest.html#cfn-ec2-ec2fleet-acceleratorcountrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of accelerators.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratorcountrequest.html#cfn-ec2-ec2fleet-acceleratorcountrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorCountRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorTotalMemoryMiBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            :param max: The maximum amount of accelerator memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of accelerator memory, in MiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratortotalmemorymibrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_total_memory_mi_bRequest_property = ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__12d4abfc68e759d9e5357219f5f252e61b8f61a3e63ec616b710599588d562e0)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of accelerator memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratortotalmemorymibrequest.html#cfn-ec2-ec2fleet-acceleratortotalmemorymibrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of accelerator memory, in MiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-acceleratortotalmemorymibrequest.html#cfn-ec2-ec2fleet-acceleratortotalmemorymibrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorTotalMemoryMiBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class BaselineEbsBandwidthMbpsRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            :param max: The maximum baseline bandwidth, in Mbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum baseline bandwidth, in Mbps. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-baselineebsbandwidthmbpsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                baseline_ebs_bandwidth_mbps_request_property = ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__e0a4de467a89057f40232d0ebf30c0027feeac4eb5957e8b9a24d27f33ef59ce)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum baseline bandwidth, in Mbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-baselineebsbandwidthmbpsrequest.html#cfn-ec2-ec2fleet-baselineebsbandwidthmbpsrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum baseline bandwidth, in Mbps.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-baselineebsbandwidthmbpsrequest.html#cfn-ec2-ec2fleet-baselineebsbandwidthmbpsrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BaselineEbsBandwidthMbpsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.CapacityRebalanceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "replacement_strategy": "replacementStrategy",
            "termination_delay": "terminationDelay",
        },
    )
    class CapacityRebalanceProperty:
        def __init__(
            self,
            *,
            replacement_strategy: typing.Optional[builtins.str] = None,
            termination_delay: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The Spot Instance replacement strategy to use when Amazon EC2 emits a rebalance notification signal that your Spot Instance is at an elevated risk of being interrupted.

            For more information, see `Capacity rebalancing <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-capacity-rebalance.html>`_ in the *Amazon EC2 User Guide* .

            :param replacement_strategy: The replacement strategy to use. Only available for fleets of type ``maintain`` . ``launch`` - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running. ``launch-before-terminate`` - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in ``TerminationDelay`` ), terminates the instances that received a rebalance notification.
            :param termination_delay: The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance. Required when ``ReplacementStrategy`` is set to ``launch-before-terminate`` . Not valid when ``ReplacementStrategy`` is set to ``launch`` . Valid values: Minimum value of ``120`` seconds. Maximum value of ``7200`` seconds.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-capacityrebalance.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                capacity_rebalance_property = ec2.CfnEC2Fleet.CapacityRebalanceProperty(
                    replacement_strategy="replacementStrategy",
                    termination_delay=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1c9644ecfacce71230069287c64c15045d2faa220f98ae11e6e91993204231d1)
                check_type(argname="argument replacement_strategy", value=replacement_strategy, expected_type=type_hints["replacement_strategy"])
                check_type(argname="argument termination_delay", value=termination_delay, expected_type=type_hints["termination_delay"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if replacement_strategy is not None:
                self._values["replacement_strategy"] = replacement_strategy
            if termination_delay is not None:
                self._values["termination_delay"] = termination_delay

        @builtins.property
        def replacement_strategy(self) -> typing.Optional[builtins.str]:
            '''The replacement strategy to use. Only available for fleets of type ``maintain`` .

            ``launch`` - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. EC2 Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.

            ``launch-before-terminate`` - EC2 Fleet launches a replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in ``TerminationDelay`` ), terminates the instances that received a rebalance notification.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-capacityrebalance.html#cfn-ec2-ec2fleet-capacityrebalance-replacementstrategy
            '''
            result = self._values.get("replacement_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def termination_delay(self) -> typing.Optional[jsii.Number]:
            '''The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance.

            Required when ``ReplacementStrategy`` is set to ``launch-before-terminate`` .

            Not valid when ``ReplacementStrategy`` is set to ``launch`` .

            Valid values: Minimum value of ``120`` seconds. Maximum value of ``7200`` seconds.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-capacityrebalance.html#cfn-ec2-ec2fleet-capacityrebalance-terminationdelay
            '''
            result = self._values.get("termination_delay")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CapacityRebalanceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.CapacityReservationOptionsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"usage_strategy": "usageStrategy"},
    )
    class CapacityReservationOptionsRequestProperty:
        def __init__(
            self,
            *,
            usage_strategy: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the strategy for using unused Capacity Reservations for fulfilling On-Demand capacity.

            .. epigraph::

               This strategy can only be used if the EC2 Fleet is of type ``instant`` .

            For more information about Capacity Reservations, see `On-Demand Capacity Reservations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html>`_ in the *Amazon EC2 User Guide* . For examples of using Capacity Reservations in an EC2 Fleet, see `EC2 Fleet example configurations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-examples.html>`_ in the *Amazon EC2 User Guide* .

            :param usage_strategy: Indicates whether to use unused Capacity Reservations for fulfilling On-Demand capacity. If you specify ``use-capacity-reservations-first`` , the fleet uses unused Capacity Reservations to fulfill On-Demand capacity up to the target On-Demand capacity. If multiple instance pools have unused Capacity Reservations, the On-Demand allocation strategy ( ``lowest-price`` or ``prioritized`` ) is applied. If the number of unused Capacity Reservations is less than the On-Demand target capacity, the remaining On-Demand target capacity is launched according to the On-Demand allocation strategy ( ``lowest-price`` or ``prioritized`` ). If you do not specify a value, the fleet fulfils the On-Demand capacity according to the chosen On-Demand allocation strategy.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-capacityreservationoptionsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                capacity_reservation_options_request_property = ec2.CfnEC2Fleet.CapacityReservationOptionsRequestProperty(
                    usage_strategy="usageStrategy"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__3e503851d3968a25a6118b10e016d02c1a13b189fe5c588615ad2269d37a9b9b)
                check_type(argname="argument usage_strategy", value=usage_strategy, expected_type=type_hints["usage_strategy"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if usage_strategy is not None:
                self._values["usage_strategy"] = usage_strategy

        @builtins.property
        def usage_strategy(self) -> typing.Optional[builtins.str]:
            '''Indicates whether to use unused Capacity Reservations for fulfilling On-Demand capacity.

            If you specify ``use-capacity-reservations-first`` , the fleet uses unused Capacity Reservations to fulfill On-Demand capacity up to the target On-Demand capacity. If multiple instance pools have unused Capacity Reservations, the On-Demand allocation strategy ( ``lowest-price`` or ``prioritized`` ) is applied. If the number of unused Capacity Reservations is less than the On-Demand target capacity, the remaining On-Demand target capacity is launched according to the On-Demand allocation strategy ( ``lowest-price`` or ``prioritized`` ).

            If you do not specify a value, the fleet fulfils the On-Demand capacity according to the chosen On-Demand allocation strategy.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-capacityreservationoptionsrequest.html#cfn-ec2-ec2fleet-capacityreservationoptionsrequest-usagestrategy
            '''
            result = self._values.get("usage_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CapacityReservationOptionsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "launch_template_specification": "launchTemplateSpecification",
            "overrides": "overrides",
        },
    )
    class FleetLaunchTemplateConfigRequestProperty:
        def __init__(
            self,
            *,
            launch_template_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ) -> None:
            '''Specifies a launch template and overrides for an EC2 Fleet.

            ``FleetLaunchTemplateConfigRequest`` is a property of the `AWS::EC2::EC2Fleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html>`_ resource.

            :param launch_template_specification: The launch template to use. You must specify either the launch template ID or launch template name in the request.
            :param overrides: Any parameters that you specify override the same parameters in the launch template. For fleets of type ``request`` and ``maintain`` , a maximum of 300 items is allowed across all launch templates.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                fleet_launch_template_config_request_property = ec2.CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty(
                    launch_template_specification=ec2.CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty(
                        version="version",
                
                        # the properties below are optional
                        launch_template_id="launchTemplateId",
                        launch_template_name="launchTemplateName"
                    ),
                    overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                        availability_zone="availabilityZone",
                        instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        max_price="maxPrice",
                        placement=ec2.CfnEC2Fleet.PlacementProperty(
                            affinity="affinity",
                            availability_zone="availabilityZone",
                            group_name="groupName",
                            host_id="hostId",
                            host_resource_group_arn="hostResourceGroupArn",
                            partition_number=123,
                            spread_domain="spreadDomain",
                            tenancy="tenancy"
                        ),
                        priority=123,
                        subnet_id="subnetId",
                        weighted_capacity=123
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__a16391ac858f174f4e714e8b72b94e7e61e1b50ead8e638dff708e3d739752d5)
                check_type(argname="argument launch_template_specification", value=launch_template_specification, expected_type=type_hints["launch_template_specification"])
                check_type(argname="argument overrides", value=overrides, expected_type=type_hints["overrides"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if launch_template_specification is not None:
                self._values["launch_template_specification"] = launch_template_specification
            if overrides is not None:
                self._values["overrides"] = overrides

        @builtins.property
        def launch_template_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty"]]:
            '''The launch template to use.

            You must specify either the launch template ID or launch template name in the request.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateconfigrequest-launchtemplatespecification
            '''
            result = self._values.get("launch_template_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty"]], result)

        @builtins.property
        def overrides(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty"]]]]:
            '''Any parameters that you specify override the same parameters in the launch template.

            For fleets of type ``request`` and ``maintain`` , a maximum of 300 items is allowed across all launch templates.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateconfigrequest-overrides
            '''
            result = self._values.get("overrides")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty"]]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FleetLaunchTemplateConfigRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "availability_zone": "availabilityZone",
            "instance_requirements": "instanceRequirements",
            "instance_type": "instanceType",
            "max_price": "maxPrice",
            "placement": "placement",
            "priority": "priority",
            "subnet_id": "subnetId",
            "weighted_capacity": "weightedCapacity",
        },
    )
    class FleetLaunchTemplateOverridesRequestProperty:
        def __init__(
            self,
            *,
            availability_zone: typing.Optional[builtins.str] = None,
            instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.InstanceRequirementsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_type: typing.Optional[builtins.str] = None,
            max_price: typing.Optional[builtins.str] = None,
            placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.PlacementProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            priority: typing.Optional[jsii.Number] = None,
            subnet_id: typing.Optional[builtins.str] = None,
            weighted_capacity: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies overrides for a launch template for an EC2 Fleet.

            ``FleetLaunchTemplateOverridesRequest`` is a property of the `FleetLaunchTemplateConfigRequest <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html>`_ property type.

            :param availability_zone: The Availability Zone in which to launch the instances.
            :param instance_requirements: The attributes for the instance types. When you specify instance attributes, Amazon EC2 will identify instance types with those attributes. .. epigraph:: If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .
            :param instance_type: The instance type. ``mac1.metal`` is not supported as a launch template override. .. epigraph:: If you specify ``InstanceType`` , you can't specify ``InstanceRequirements`` .
            :param max_price: The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.
            :param placement: The location where the instance launched, if applicable.
            :param priority: The priority for the launch template override. The highest priority is launched first. If the On-Demand ``AllocationStrategy`` is set to ``prioritized`` , EC2 Fleet uses priority to determine which launch template override to use first in fulfilling On-Demand capacity. If the Spot ``AllocationStrategy`` is set to ``capacity-optimized-prioritized`` , EC2 Fleet uses priority on a best-effort basis to determine which launch template override to use in fulfilling Spot capacity, but optimizes for capacity first. Valid values are whole numbers starting at ``0`` . The lower the number, the higher the priority. If no number is set, the launch template override has the lowest priority. You can set the same priority for different launch template overrides.
            :param subnet_id: The IDs of the subnets in which to launch the instances. Separate multiple subnet IDs using commas (for example, ``subnet-1234abcdeexample1, subnet-0987cdef6example2`` ). A request of type ``instant`` can have only one subnet ID.
            :param weighted_capacity: The number of units provided by the specified instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                fleet_launch_template_overrides_request_property = ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                    availability_zone="availabilityZone",
                    instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                        accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        memory_gi_bPer_vCpu=ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    max_price="maxPrice",
                    placement=ec2.CfnEC2Fleet.PlacementProperty(
                        affinity="affinity",
                        availability_zone="availabilityZone",
                        group_name="groupName",
                        host_id="hostId",
                        host_resource_group_arn="hostResourceGroupArn",
                        partition_number=123,
                        spread_domain="spreadDomain",
                        tenancy="tenancy"
                    ),
                    priority=123,
                    subnet_id="subnetId",
                    weighted_capacity=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d758750d188cce1b749f19591d20310ad5bc697f0e6f94f495c9619297998763)
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
                check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                check_type(argname="argument max_price", value=max_price, expected_type=type_hints["max_price"])
                check_type(argname="argument placement", value=placement, expected_type=type_hints["placement"])
                check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
                check_type(argname="argument weighted_capacity", value=weighted_capacity, expected_type=type_hints["weighted_capacity"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if instance_requirements is not None:
                self._values["instance_requirements"] = instance_requirements
            if instance_type is not None:
                self._values["instance_type"] = instance_type
            if max_price is not None:
                self._values["max_price"] = max_price
            if placement is not None:
                self._values["placement"] = placement
            if priority is not None:
                self._values["priority"] = priority
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id
            if weighted_capacity is not None:
                self._values["weighted_capacity"] = weighted_capacity

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone in which to launch the instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_requirements(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.InstanceRequirementsRequestProperty"]]:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with those attributes.
            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-instancerequirements
            '''
            result = self._values.get("instance_requirements")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.InstanceRequirementsRequestProperty"]], result)

        @builtins.property
        def instance_type(self) -> typing.Optional[builtins.str]:
            '''The instance type.

            ``mac1.metal`` is not supported as a launch template override.
            .. epigraph::

               If you specify ``InstanceType`` , you can't specify ``InstanceRequirements`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-instancetype
            '''
            result = self._values.get("instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def max_price(self) -> typing.Optional[builtins.str]:
            '''The maximum price per unit hour that you are willing to pay for a Spot Instance.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-maxprice
            '''
            result = self._values.get("max_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def placement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.PlacementProperty"]]:
            '''The location where the instance launched, if applicable.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-placement
            '''
            result = self._values.get("placement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.PlacementProperty"]], result)

        @builtins.property
        def priority(self) -> typing.Optional[jsii.Number]:
            '''The priority for the launch template override. The highest priority is launched first.

            If the On-Demand ``AllocationStrategy`` is set to ``prioritized`` , EC2 Fleet uses priority to determine which launch template override to use first in fulfilling On-Demand capacity.

            If the Spot ``AllocationStrategy`` is set to ``capacity-optimized-prioritized`` , EC2 Fleet uses priority on a best-effort basis to determine which launch template override to use in fulfilling Spot capacity, but optimizes for capacity first.

            Valid values are whole numbers starting at ``0`` . The lower the number, the higher the priority. If no number is set, the launch template override has the lowest priority. You can set the same priority for different launch template overrides.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-priority
            '''
            result = self._values.get("priority")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The IDs of the subnets in which to launch the instances.

            Separate multiple subnet IDs using commas (for example, ``subnet-1234abcdeexample1, subnet-0987cdef6example2`` ). A request of type ``instant`` can have only one subnet ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def weighted_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of units provided by the specified instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-weightedcapacity
            '''
            result = self._values.get("weighted_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FleetLaunchTemplateOverridesRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "version": "version",
            "launch_template_id": "launchTemplateId",
            "launch_template_name": "launchTemplateName",
        },
    )
    class FleetLaunchTemplateSpecificationRequestProperty:
        def __init__(
            self,
            *,
            version: builtins.str,
            launch_template_id: typing.Optional[builtins.str] = None,
            launch_template_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the launch template to be used by the EC2 Fleet for configuring Amazon EC2 instances.

            You must specify the following:

            - The ID or the name of the launch template, but not both.
            - The version of the launch template.

            ``FleetLaunchTemplateSpecificationRequest`` is a property of the `FleetLaunchTemplateConfigRequest <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html>`_ property type.

            For information about creating a launch template, see `AWS::EC2::LaunchTemplate <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html>`_ and `Create a launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ in the *Amazon EC2 User Guide* .

            For examples of launch templates, see `Examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples>`_ .

            :param version: The launch template version number, ``$Latest`` , or ``$Default`` . You must specify a value, otherwise the request fails. If the value is ``$Latest`` , Amazon EC2 uses the latest version of the launch template. If the value is ``$Default`` , Amazon EC2 uses the default version of the launch template.
            :param launch_template_id: The ID of the launch template. You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.
            :param launch_template_name: The name of the launch template. You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                fleet_launch_template_specification_request_property = ec2.CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty(
                    version="version",
                
                    # the properties below are optional
                    launch_template_id="launchTemplateId",
                    launch_template_name="launchTemplateName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d89df5a41143fa7395201e459ee2a2dbb7ec441738ee1a58eac3f6d95e953971)
                check_type(argname="argument version", value=version, expected_type=type_hints["version"])
                check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
                check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "version": version,
            }
            if launch_template_id is not None:
                self._values["launch_template_id"] = launch_template_id
            if launch_template_name is not None:
                self._values["launch_template_name"] = launch_template_name

        @builtins.property
        def version(self) -> builtins.str:
            '''The launch template version number, ``$Latest`` , or ``$Default`` . You must specify a value, otherwise the request fails.

            If the value is ``$Latest`` , Amazon EC2 uses the latest version of the launch template.

            If the value is ``$Default`` , Amazon EC2 uses the default version of the launch template.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest-version
            '''
            result = self._values.get("version")
            assert result is not None, "Required property 'version' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def launch_template_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the launch template.

            You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest-launchtemplateid
            '''
            result = self._values.get("launch_template_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def launch_template_name(self) -> typing.Optional[builtins.str]:
            '''The name of the launch template.

            You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplatespecificationrequest-launchtemplatename
            '''
            result = self._values.get("launch_template_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FleetLaunchTemplateSpecificationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "accelerator_count": "acceleratorCount",
            "accelerator_manufacturers": "acceleratorManufacturers",
            "accelerator_names": "acceleratorNames",
            "accelerator_total_memory_mib": "acceleratorTotalMemoryMiB",
            "accelerator_types": "acceleratorTypes",
            "allowed_instance_types": "allowedInstanceTypes",
            "bare_metal": "bareMetal",
            "baseline_ebs_bandwidth_mbps": "baselineEbsBandwidthMbps",
            "burstable_performance": "burstablePerformance",
            "cpu_manufacturers": "cpuManufacturers",
            "excluded_instance_types": "excludedInstanceTypes",
            "instance_generations": "instanceGenerations",
            "local_storage": "localStorage",
            "local_storage_types": "localStorageTypes",
            "memory_gib_per_v_cpu": "memoryGiBPerVCpu",
            "memory_mib": "memoryMiB",
            "network_bandwidth_gbps": "networkBandwidthGbps",
            "network_interface_count": "networkInterfaceCount",
            "on_demand_max_price_percentage_over_lowest_price": "onDemandMaxPricePercentageOverLowestPrice",
            "require_hibernate_support": "requireHibernateSupport",
            "spot_max_price_percentage_over_lowest_price": "spotMaxPricePercentageOverLowestPrice",
            "total_local_storage_gb": "totalLocalStorageGb",
            "v_cpu_count": "vCpuCount",
        },
    )
    class InstanceRequirementsRequestProperty:
        def __init__(
            self,
            *,
            accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.AcceleratorCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            bare_metal: typing.Optional[builtins.str] = None,
            baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            burstable_performance: typing.Optional[builtins.str] = None,
            cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
            local_storage: typing.Optional[builtins.str] = None,
            local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.MemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.NetworkInterfaceCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.TotalLocalStorageGBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.VCpuCountRangeRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with these attributes.

            You must specify ``VCpuCount`` and ``MemoryMiB`` . All other attributes are optional. Any unspecified optional attribute is set to its default.

            When you specify multiple attributes, you get instance types that satisfy all of the specified attributes. If you specify multiple values for an attribute, you get instance types that satisfy any of the specified values.

            To limit the list of instance types from which Amazon EC2 can identify matching instance types, you can use one of the following parameters, but not both in the same request:

            - ``AllowedInstanceTypes`` - The instance types to include in the list. All other instance types are ignored, even if they match your specified attributes.
            - ``ExcludedInstanceTypes`` - The instance types to exclude from the list, even if they match your specified attributes.

            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

               Attribute-based instance type selection is only supported when using Auto Scaling groups, EC2 Fleet, and Spot Fleet to launch instances. If you plan to use the launch template in the `launch instance wizard <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html>`_ , or with the `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ API or `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ AWS CloudFormation resource, you can't specify ``InstanceRequirements`` .

            For more information, see `Attribute-based instance type selection for EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html>`_ , `Attribute-based instance type selection for Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html>`_ , and `Spot placement score <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html>`_ in the *Amazon EC2 User Guide* .

            :param accelerator_count: The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` . Default: No minimum or maximum limits
            :param accelerator_manufacturers: Indicates whether instance types must have accelerators by specific manufacturers. - For instance types with AWS devices, specify ``amazon-web-services`` . - For instance types with AMD devices, specify ``amd`` . - For instance types with Habana devices, specify ``habana`` . - For instance types with NVIDIA devices, specify ``nvidia`` . - For instance types with Xilinx devices, specify ``xilinx`` . Default: Any manufacturer
            :param accelerator_names: The accelerators that must be on the instance type. - For instance types with NVIDIA A10G GPUs, specify ``a10g`` . - For instance types with NVIDIA A100 GPUs, specify ``a100`` . - For instance types with NVIDIA H100 GPUs, specify ``h100`` . - For instance types with AWS Inferentia chips, specify ``inferentia`` . - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` . - For instance types with NVIDIA K80 GPUs, specify ``k80`` . - For instance types with NVIDIA M60 GPUs, specify ``m60`` . - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` . - For instance types with NVIDIA T4 GPUs, specify ``t4`` . - For instance types with NVIDIA T4G GPUs, specify ``t4g`` . - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` . - For instance types with NVIDIA V100 GPUs, specify ``v100`` . Default: Any accelerator
            :param accelerator_total_memory_mib: The minimum and maximum amount of total accelerator memory, in MiB. Default: No minimum or maximum limits
            :param accelerator_types: The accelerator types that must be on the instance type. - To include instance types with GPU hardware, specify ``gpu`` . - To include instance types with FPGA hardware, specify ``fpga`` . - To include instance types with inference hardware, specify ``inference`` . Default: Any accelerator type
            :param allowed_instance_types: The instance types to apply your specified attributes against. All other instance types are ignored, even if they match your specified attributes. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` . Default: All instance types
            :param bare_metal: Indicates whether bare metal instance types must be included, excluded, or required. - To include bare metal instance types, specify ``included`` . - To require only bare metal instance types, specify ``required`` . - To exclude bare metal instance types, specify ``excluded`` . Default: ``excluded``
            :param baseline_ebs_bandwidth_mbps: The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps. For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* . Default: No minimum or maximum limits
            :param burstable_performance: Indicates whether burstable performance T instance types are included, excluded, or required. For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ . - To include burstable performance instance types, specify ``included`` . - To require only burstable performance instance types, specify ``required`` . - To exclude burstable performance instance types, specify ``excluded`` . Default: ``excluded``
            :param cpu_manufacturers: The CPU manufacturers to include. - For instance types with Intel CPUs, specify ``intel`` . - For instance types with AMD CPUs, specify ``amd`` . - For instance types with AWS CPUs, specify ``amazon-web-services`` . .. epigraph:: Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template. Default: Any manufacturer
            :param excluded_instance_types: The instance types to exclude. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance family, type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` . Default: No excluded instance types
            :param instance_generations: Indicates whether current or previous generation instance types are included. The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* . For current generation instance types, specify ``current`` . For previous generation instance types, specify ``previous`` . Default: Current and previous generation instance types
            :param local_storage: Indicates whether instance types with instance store volumes are included, excluded, or required. For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* . - To include instance types with instance store volumes, specify ``included`` . - To require only instance types with instance store volumes, specify ``required`` . - To exclude instance types with instance store volumes, specify ``excluded`` . Default: ``included``
            :param local_storage_types: The type of local storage that is required. - For instance types with hard disk drive (HDD) storage, specify ``hdd`` . - For instance types with solid state drive (SSD) storage, specify ``ssd`` . Default: ``hdd`` and ``ssd``
            :param memory_gib_per_v_cpu: The minimum and maximum amount of memory per vCPU, in GiB. Default: No minimum or maximum limits
            :param memory_mib: The minimum and maximum amount of memory, in MiB.
            :param network_bandwidth_gbps: The minimum and maximum amount of baseline network bandwidth, in gigabits per second (Gbps). For more information, see `Amazon EC2 instance network bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html>`_ in the *Amazon EC2 User Guide* . Default: No minimum or maximum limits
            :param network_interface_count: The minimum and maximum number of network interfaces. Default: No minimum or maximum limits
            :param on_demand_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. Default: ``20``
            :param require_hibernate_support: Indicates whether instance types must support hibernation for On-Demand Instances. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ . Default: ``false``
            :param spot_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price. The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` . Default: ``100``
            :param total_local_storage_gb: The minimum and maximum amount of total local storage, in GB. Default: No minimum or maximum limits
            :param v_cpu_count: The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_requirements_request_property = ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                    accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_manufacturers=["acceleratorManufacturers"],
                    accelerator_names=["acceleratorNames"],
                    accelerator_total_memory_mi_b=ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_types=["acceleratorTypes"],
                    allowed_instance_types=["allowedInstanceTypes"],
                    bare_metal="bareMetal",
                    baseline_ebs_bandwidth_mbps=ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                        max=123,
                        min=123
                    ),
                    burstable_performance="burstablePerformance",
                    cpu_manufacturers=["cpuManufacturers"],
                    excluded_instance_types=["excludedInstanceTypes"],
                    instance_generations=["instanceGenerations"],
                    local_storage="localStorage",
                    local_storage_types=["localStorageTypes"],
                    memory_gi_bPer_vCpu=ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                        max=123,
                        min=123
                    ),
                    memory_mi_b=ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                        max=123,
                        min=123
                    ),
                    network_bandwidth_gbps=ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                        max=123,
                        min=123
                    ),
                    network_interface_count=ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                        max=123,
                        min=123
                    ),
                    on_demand_max_price_percentage_over_lowest_price=123,
                    require_hibernate_support=False,
                    spot_max_price_percentage_over_lowest_price=123,
                    total_local_storage_gb=ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                        max=123,
                        min=123
                    ),
                    v_cpu_count=ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                        max=123,
                        min=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__a5fc35aff5e96972c3cf7c89fef75da6adc5eb146fd5504925579235a4de6e0a)
                check_type(argname="argument accelerator_count", value=accelerator_count, expected_type=type_hints["accelerator_count"])
                check_type(argname="argument accelerator_manufacturers", value=accelerator_manufacturers, expected_type=type_hints["accelerator_manufacturers"])
                check_type(argname="argument accelerator_names", value=accelerator_names, expected_type=type_hints["accelerator_names"])
                check_type(argname="argument accelerator_total_memory_mib", value=accelerator_total_memory_mib, expected_type=type_hints["accelerator_total_memory_mib"])
                check_type(argname="argument accelerator_types", value=accelerator_types, expected_type=type_hints["accelerator_types"])
                check_type(argname="argument allowed_instance_types", value=allowed_instance_types, expected_type=type_hints["allowed_instance_types"])
                check_type(argname="argument bare_metal", value=bare_metal, expected_type=type_hints["bare_metal"])
                check_type(argname="argument baseline_ebs_bandwidth_mbps", value=baseline_ebs_bandwidth_mbps, expected_type=type_hints["baseline_ebs_bandwidth_mbps"])
                check_type(argname="argument burstable_performance", value=burstable_performance, expected_type=type_hints["burstable_performance"])
                check_type(argname="argument cpu_manufacturers", value=cpu_manufacturers, expected_type=type_hints["cpu_manufacturers"])
                check_type(argname="argument excluded_instance_types", value=excluded_instance_types, expected_type=type_hints["excluded_instance_types"])
                check_type(argname="argument instance_generations", value=instance_generations, expected_type=type_hints["instance_generations"])
                check_type(argname="argument local_storage", value=local_storage, expected_type=type_hints["local_storage"])
                check_type(argname="argument local_storage_types", value=local_storage_types, expected_type=type_hints["local_storage_types"])
                check_type(argname="argument memory_gib_per_v_cpu", value=memory_gib_per_v_cpu, expected_type=type_hints["memory_gib_per_v_cpu"])
                check_type(argname="argument memory_mib", value=memory_mib, expected_type=type_hints["memory_mib"])
                check_type(argname="argument network_bandwidth_gbps", value=network_bandwidth_gbps, expected_type=type_hints["network_bandwidth_gbps"])
                check_type(argname="argument network_interface_count", value=network_interface_count, expected_type=type_hints["network_interface_count"])
                check_type(argname="argument on_demand_max_price_percentage_over_lowest_price", value=on_demand_max_price_percentage_over_lowest_price, expected_type=type_hints["on_demand_max_price_percentage_over_lowest_price"])
                check_type(argname="argument require_hibernate_support", value=require_hibernate_support, expected_type=type_hints["require_hibernate_support"])
                check_type(argname="argument spot_max_price_percentage_over_lowest_price", value=spot_max_price_percentage_over_lowest_price, expected_type=type_hints["spot_max_price_percentage_over_lowest_price"])
                check_type(argname="argument total_local_storage_gb", value=total_local_storage_gb, expected_type=type_hints["total_local_storage_gb"])
                check_type(argname="argument v_cpu_count", value=v_cpu_count, expected_type=type_hints["v_cpu_count"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if accelerator_count is not None:
                self._values["accelerator_count"] = accelerator_count
            if accelerator_manufacturers is not None:
                self._values["accelerator_manufacturers"] = accelerator_manufacturers
            if accelerator_names is not None:
                self._values["accelerator_names"] = accelerator_names
            if accelerator_total_memory_mib is not None:
                self._values["accelerator_total_memory_mib"] = accelerator_total_memory_mib
            if accelerator_types is not None:
                self._values["accelerator_types"] = accelerator_types
            if allowed_instance_types is not None:
                self._values["allowed_instance_types"] = allowed_instance_types
            if bare_metal is not None:
                self._values["bare_metal"] = bare_metal
            if baseline_ebs_bandwidth_mbps is not None:
                self._values["baseline_ebs_bandwidth_mbps"] = baseline_ebs_bandwidth_mbps
            if burstable_performance is not None:
                self._values["burstable_performance"] = burstable_performance
            if cpu_manufacturers is not None:
                self._values["cpu_manufacturers"] = cpu_manufacturers
            if excluded_instance_types is not None:
                self._values["excluded_instance_types"] = excluded_instance_types
            if instance_generations is not None:
                self._values["instance_generations"] = instance_generations
            if local_storage is not None:
                self._values["local_storage"] = local_storage
            if local_storage_types is not None:
                self._values["local_storage_types"] = local_storage_types
            if memory_gib_per_v_cpu is not None:
                self._values["memory_gib_per_v_cpu"] = memory_gib_per_v_cpu
            if memory_mib is not None:
                self._values["memory_mib"] = memory_mib
            if network_bandwidth_gbps is not None:
                self._values["network_bandwidth_gbps"] = network_bandwidth_gbps
            if network_interface_count is not None:
                self._values["network_interface_count"] = network_interface_count
            if on_demand_max_price_percentage_over_lowest_price is not None:
                self._values["on_demand_max_price_percentage_over_lowest_price"] = on_demand_max_price_percentage_over_lowest_price
            if require_hibernate_support is not None:
                self._values["require_hibernate_support"] = require_hibernate_support
            if spot_max_price_percentage_over_lowest_price is not None:
                self._values["spot_max_price_percentage_over_lowest_price"] = spot_max_price_percentage_over_lowest_price
            if total_local_storage_gb is not None:
                self._values["total_local_storage_gb"] = total_local_storage_gb
            if v_cpu_count is not None:
                self._values["v_cpu_count"] = v_cpu_count

        @builtins.property
        def accelerator_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.AcceleratorCountRequestProperty"]]:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-acceleratorcount
            '''
            result = self._values.get("accelerator_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.AcceleratorCountRequestProperty"]], result)

        @builtins.property
        def accelerator_manufacturers(
            self,
        ) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether instance types must have accelerators by specific manufacturers.

            - For instance types with AWS devices, specify ``amazon-web-services`` .
            - For instance types with AMD devices, specify ``amd`` .
            - For instance types with Habana devices, specify ``habana`` .
            - For instance types with NVIDIA devices, specify ``nvidia`` .
            - For instance types with Xilinx devices, specify ``xilinx`` .

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-acceleratormanufacturers
            '''
            result = self._values.get("accelerator_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_names(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerators that must be on the instance type.

            - For instance types with NVIDIA A10G GPUs, specify ``a10g`` .
            - For instance types with NVIDIA A100 GPUs, specify ``a100`` .
            - For instance types with NVIDIA H100 GPUs, specify ``h100`` .
            - For instance types with AWS Inferentia chips, specify ``inferentia`` .
            - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` .
            - For instance types with NVIDIA K80 GPUs, specify ``k80`` .
            - For instance types with NVIDIA M60 GPUs, specify ``m60`` .
            - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` .
            - For instance types with NVIDIA T4 GPUs, specify ``t4`` .
            - For instance types with NVIDIA T4G GPUs, specify ``t4g`` .
            - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` .
            - For instance types with NVIDIA V100 GPUs, specify ``v100`` .

            Default: Any accelerator

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-acceleratornames
            '''
            result = self._values.get("accelerator_names")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_total_memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty"]]:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-acceleratortotalmemorymib
            '''
            result = self._values.get("accelerator_total_memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty"]], result)

        @builtins.property
        def accelerator_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerator types that must be on the instance type.

            - To include instance types with GPU hardware, specify ``gpu`` .
            - To include instance types with FPGA hardware, specify ``fpga`` .
            - To include instance types with inference hardware, specify ``inference`` .

            Default: Any accelerator type

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-acceleratortypes
            '''
            result = self._values.get("accelerator_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def allowed_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to apply your specified attributes against.

            All other instance types are ignored, even if they match your specified attributes.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` .

            Default: All instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-allowedinstancetypes
            '''
            result = self._values.get("allowed_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def bare_metal(self) -> typing.Optional[builtins.str]:
            '''Indicates whether bare metal instance types must be included, excluded, or required.

            - To include bare metal instance types, specify ``included`` .
            - To require only bare metal instance types, specify ``required`` .
            - To exclude bare metal instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-baremetal
            '''
            result = self._values.get("bare_metal")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def baseline_ebs_bandwidth_mbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty"]]:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-baselineebsbandwidthmbps
            '''
            result = self._values.get("baseline_ebs_bandwidth_mbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty"]], result)

        @builtins.property
        def burstable_performance(self) -> typing.Optional[builtins.str]:
            '''Indicates whether burstable performance T instance types are included, excluded, or required.

            For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ .

            - To include burstable performance instance types, specify ``included`` .
            - To require only burstable performance instance types, specify ``required`` .
            - To exclude burstable performance instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-burstableperformance
            '''
            result = self._values.get("burstable_performance")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cpu_manufacturers(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The CPU manufacturers to include.

            - For instance types with Intel CPUs, specify ``intel`` .
            - For instance types with AMD CPUs, specify ``amd`` .
            - For instance types with AWS CPUs, specify ``amazon-web-services`` .

            .. epigraph::

               Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template.

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-cpumanufacturers
            '''
            result = self._values.get("cpu_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def excluded_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to exclude.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance family, type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` .

            Default: No excluded instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-excludedinstancetypes
            '''
            result = self._values.get("excluded_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def instance_generations(self) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether current or previous generation instance types are included.

            The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .

            For current generation instance types, specify ``current`` .

            For previous generation instance types, specify ``previous`` .

            Default: Current and previous generation instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-instancegenerations
            '''
            result = self._values.get("instance_generations")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def local_storage(self) -> typing.Optional[builtins.str]:
            '''Indicates whether instance types with instance store volumes are included, excluded, or required.

            For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* .

            - To include instance types with instance store volumes, specify ``included`` .
            - To require only instance types with instance store volumes, specify ``required`` .
            - To exclude instance types with instance store volumes, specify ``excluded`` .

            Default: ``included``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-localstorage
            '''
            result = self._values.get("local_storage")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def local_storage_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The type of local storage that is required.

            - For instance types with hard disk drive (HDD) storage, specify ``hdd`` .
            - For instance types with solid state drive (SSD) storage, specify ``ssd`` .

            Default: ``hdd`` and ``ssd``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-localstoragetypes
            '''
            result = self._values.get("local_storage_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def memory_gib_per_v_cpu(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty"]]:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-memorygibpervcpu
            '''
            result = self._values.get("memory_gib_per_v_cpu")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty"]], result)

        @builtins.property
        def memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MemoryMiBRequestProperty"]]:
            '''The minimum and maximum amount of memory, in MiB.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-memorymib
            '''
            result = self._values.get("memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MemoryMiBRequestProperty"]], result)

        @builtins.property
        def network_bandwidth_gbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty"]]:
            '''The minimum and maximum amount of baseline network bandwidth, in gigabits per second (Gbps).

            For more information, see `Amazon EC2 instance network bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-networkbandwidthgbps
            '''
            result = self._values.get("network_bandwidth_gbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty"]], result)

        @builtins.property
        def network_interface_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.NetworkInterfaceCountRequestProperty"]]:
            '''The minimum and maximum number of network interfaces.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-networkinterfacecount
            '''
            result = self._values.get("network_interface_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.NetworkInterfaceCountRequestProperty"]], result)

        @builtins.property
        def on_demand_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price.

            The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            Default: ``20``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-ondemandmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("on_demand_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def require_hibernate_support(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether instance types must support hibernation for On-Demand Instances.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ .

            Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-requirehibernatesupport
            '''
            result = self._values.get("require_hibernate_support")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def spot_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price.

            The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` .

            Default: ``100``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-spotmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("spot_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def total_local_storage_gb(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TotalLocalStorageGBRequestProperty"]]:
            '''The minimum and maximum amount of total local storage, in GB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-totallocalstoragegb
            '''
            result = self._values.get("total_local_storage_gb")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.TotalLocalStorageGBRequestProperty"]], result)

        @builtins.property
        def v_cpu_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.VCpuCountRangeRequestProperty"]]:
            '''The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-instancerequirementsrequest.html#cfn-ec2-ec2fleet-instancerequirementsrequest-vcpucount
            '''
            result = self._values.get("v_cpu_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.VCpuCountRangeRequestProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceRequirementsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.MaintenanceStrategiesProperty",
        jsii_struct_bases=[],
        name_mapping={"capacity_rebalance": "capacityRebalance"},
    )
    class MaintenanceStrategiesProperty:
        def __init__(
            self,
            *,
            capacity_rebalance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.CapacityRebalanceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

            :param capacity_rebalance: The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-maintenancestrategies.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                maintenance_strategies_property = ec2.CfnEC2Fleet.MaintenanceStrategiesProperty(
                    capacity_rebalance=ec2.CfnEC2Fleet.CapacityRebalanceProperty(
                        replacement_strategy="replacementStrategy",
                        termination_delay=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__74a54f8579657c5e4deb0c052567cd4660664c3fcc6d9232bbc646b1ee0c421e)
                check_type(argname="argument capacity_rebalance", value=capacity_rebalance, expected_type=type_hints["capacity_rebalance"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if capacity_rebalance is not None:
                self._values["capacity_rebalance"] = capacity_rebalance

        @builtins.property
        def capacity_rebalance(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.CapacityRebalanceProperty"]]:
            '''The strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-maintenancestrategies.html#cfn-ec2-ec2fleet-maintenancestrategies-capacityrebalance
            '''
            result = self._values.get("capacity_rebalance")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.CapacityRebalanceProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MaintenanceStrategiesProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryGiBPerVCpuRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            :param max: The maximum amount of memory per vCPU, in GiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory per vCPU, in GiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorygibpervcpurequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_gi_bPer_vCpu_request_property = ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b60bc2d12a913968d0d316eb200c86e5d9ecf567ed9b6c6e51cdbd1a0b417422)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory per vCPU, in GiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorygibpervcpurequest.html#cfn-ec2-ec2fleet-memorygibpervcpurequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory per vCPU, in GiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorygibpervcpurequest.html#cfn-ec2-ec2fleet-memorygibpervcpurequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryGiBPerVCpuRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.MemoryMiBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryMiBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory, in MiB.

            :param max: The maximum amount of memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory, in MiB. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorymibrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_mi_bRequest_property = ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__582bf0e6109937779c349eb63366e7e4cdaa15b4c199c2ec484777174cd8b7d4)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorymibrequest.html#cfn-ec2-ec2fleet-memorymibrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory, in MiB.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-memorymibrequest.html#cfn-ec2-ec2fleet-memorymibrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryMiBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkBandwidthGbpsRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of network bandwidth, in gigabits per second (Gbps).

            .. epigraph::

               Setting the minimum bandwidth does not guarantee that your instance will achieve the minimum bandwidth. Amazon EC2 will identify instance types that support the specified minimum bandwidth, but the actual bandwidth of your instance might go below the specified minimum at times. For more information, see `Available instance bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html#available-instance-bandwidth>`_ in the *Amazon EC2 User Guide* .

            :param max: The maximum amount of network bandwidth, in Gbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of network bandwidth, in Gbps. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkbandwidthgbpsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_bandwidth_gbps_request_property = ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__a1631d95b133eba9c84f539d999721b9029fe1ac10dad3c41c3cf7362e6dcf23)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of network bandwidth, in Gbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkbandwidthgbpsrequest.html#cfn-ec2-ec2fleet-networkbandwidthgbpsrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of network bandwidth, in Gbps.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkbandwidthgbpsrequest.html#cfn-ec2-ec2fleet-networkbandwidthgbpsrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkBandwidthGbpsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkInterfaceCountRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of network interfaces.

            :param max: The maximum number of network interfaces. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of network interfaces. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkinterfacecountrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_count_request_property = ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c1c61f48589be52f9f062634b2e52fcd4095fcad95dc9fd0bf2a68bdfe2d9829)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of network interfaces.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkinterfacecountrequest.html#cfn-ec2-ec2fleet-networkinterfacecountrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of network interfaces.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-networkinterfacecountrequest.html#cfn-ec2-ec2fleet-networkinterfacecountrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceCountRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.OnDemandOptionsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "allocation_strategy": "allocationStrategy",
            "capacity_reservation_options": "capacityReservationOptions",
            "max_total_price": "maxTotalPrice",
            "min_target_capacity": "minTargetCapacity",
            "single_availability_zone": "singleAvailabilityZone",
            "single_instance_type": "singleInstanceType",
        },
    )
    class OnDemandOptionsRequestProperty:
        def __init__(
            self,
            *,
            allocation_strategy: typing.Optional[builtins.str] = None,
            capacity_reservation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.CapacityReservationOptionsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            max_total_price: typing.Optional[builtins.str] = None,
            min_target_capacity: typing.Optional[jsii.Number] = None,
            single_availability_zone: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            single_instance_type: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Specifies the allocation strategy of On-Demand Instances in an EC2 Fleet.

            ``OnDemandOptionsRequest`` is a property of the `AWS::EC2::EC2Fleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html>`_ resource.

            :param allocation_strategy: The strategy that determines the order of the launch template overrides to use in fulfilling On-Demand capacity. ``lowest-price`` - EC2 Fleet uses price to determine the order, launching the lowest price first. ``prioritized`` - EC2 Fleet uses the priority that you assigned to each launch template override, launching the highest priority first. Default: ``lowest-price``
            :param capacity_reservation_options: The strategy for using unused Capacity Reservations for fulfilling On-Demand capacity. Supported only for fleets of type ``instant`` .
            :param max_total_price: The maximum amount per hour for On-Demand Instances that you're willing to pay. .. epigraph:: If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``MaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``MaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .
            :param min_target_capacity: The minimum target capacity for On-Demand Instances in the fleet. If the minimum target capacity is not reached, the fleet launches no instances. Supported only for fleets of type ``instant`` . At least one of the following must be specified: ``SingleAvailabilityZone`` | ``SingleInstanceType``
            :param single_availability_zone: Indicates that the fleet launches all On-Demand Instances into a single Availability Zone. Supported only for fleets of type ``instant`` .
            :param single_instance_type: Indicates that the fleet uses a single instance type to launch all On-Demand Instances in the fleet. Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                on_demand_options_request_property = ec2.CfnEC2Fleet.OnDemandOptionsRequestProperty(
                    allocation_strategy="allocationStrategy",
                    capacity_reservation_options=ec2.CfnEC2Fleet.CapacityReservationOptionsRequestProperty(
                        usage_strategy="usageStrategy"
                    ),
                    max_total_price="maxTotalPrice",
                    min_target_capacity=123,
                    single_availability_zone=False,
                    single_instance_type=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__dce716d2e517f4e8c297cb02cd9e5e88232758cb9732040686bdfb59b38c71c3)
                check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
                check_type(argname="argument capacity_reservation_options", value=capacity_reservation_options, expected_type=type_hints["capacity_reservation_options"])
                check_type(argname="argument max_total_price", value=max_total_price, expected_type=type_hints["max_total_price"])
                check_type(argname="argument min_target_capacity", value=min_target_capacity, expected_type=type_hints["min_target_capacity"])
                check_type(argname="argument single_availability_zone", value=single_availability_zone, expected_type=type_hints["single_availability_zone"])
                check_type(argname="argument single_instance_type", value=single_instance_type, expected_type=type_hints["single_instance_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if allocation_strategy is not None:
                self._values["allocation_strategy"] = allocation_strategy
            if capacity_reservation_options is not None:
                self._values["capacity_reservation_options"] = capacity_reservation_options
            if max_total_price is not None:
                self._values["max_total_price"] = max_total_price
            if min_target_capacity is not None:
                self._values["min_target_capacity"] = min_target_capacity
            if single_availability_zone is not None:
                self._values["single_availability_zone"] = single_availability_zone
            if single_instance_type is not None:
                self._values["single_instance_type"] = single_instance_type

        @builtins.property
        def allocation_strategy(self) -> typing.Optional[builtins.str]:
            '''The strategy that determines the order of the launch template overrides to use in fulfilling On-Demand capacity.

            ``lowest-price`` - EC2 Fleet uses price to determine the order, launching the lowest price first.

            ``prioritized`` - EC2 Fleet uses the priority that you assigned to each launch template override, launching the highest priority first.

            Default: ``lowest-price``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-allocationstrategy
            '''
            result = self._values.get("allocation_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def capacity_reservation_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.CapacityReservationOptionsRequestProperty"]]:
            '''The strategy for using unused Capacity Reservations for fulfilling On-Demand capacity.

            Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-capacityreservationoptions
            '''
            result = self._values.get("capacity_reservation_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.CapacityReservationOptionsRequestProperty"]], result)

        @builtins.property
        def max_total_price(self) -> typing.Optional[builtins.str]:
            '''The maximum amount per hour for On-Demand Instances that you're willing to pay.

            .. epigraph::

               If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``MaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``MaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-maxtotalprice
            '''
            result = self._values.get("max_total_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def min_target_capacity(self) -> typing.Optional[jsii.Number]:
            '''The minimum target capacity for On-Demand Instances in the fleet.

            If the minimum target capacity is not reached, the fleet launches no instances.

            Supported only for fleets of type ``instant`` .

            At least one of the following must be specified: ``SingleAvailabilityZone`` | ``SingleInstanceType``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-mintargetcapacity
            '''
            result = self._values.get("min_target_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def single_availability_zone(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates that the fleet launches all On-Demand Instances into a single Availability Zone.

            Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-singleavailabilityzone
            '''
            result = self._values.get("single_availability_zone")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def single_instance_type(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates that the fleet uses a single instance type to launch all On-Demand Instances in the fleet.

            Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ondemandoptionsrequest.html#cfn-ec2-ec2fleet-ondemandoptionsrequest-singleinstancetype
            '''
            result = self._values.get("single_instance_type")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "OnDemandOptionsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.PlacementProperty",
        jsii_struct_bases=[],
        name_mapping={
            "affinity": "affinity",
            "availability_zone": "availabilityZone",
            "group_name": "groupName",
            "host_id": "hostId",
            "host_resource_group_arn": "hostResourceGroupArn",
            "partition_number": "partitionNumber",
            "spread_domain": "spreadDomain",
            "tenancy": "tenancy",
        },
    )
    class PlacementProperty:
        def __init__(
            self,
            *,
            affinity: typing.Optional[builtins.str] = None,
            availability_zone: typing.Optional[builtins.str] = None,
            group_name: typing.Optional[builtins.str] = None,
            host_id: typing.Optional[builtins.str] = None,
            host_resource_group_arn: typing.Optional[builtins.str] = None,
            partition_number: typing.Optional[jsii.Number] = None,
            spread_domain: typing.Optional[builtins.str] = None,
            tenancy: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the placement of an instance.

            :param affinity: The affinity setting for the instance on the Dedicated Host. This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ or `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ .
            :param availability_zone: The Availability Zone of the instance. If not specified, an Availability Zone will be automatically chosen for you based on the load balancing criteria for the Region. This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .
            :param group_name: The name of the placement group that the instance is in. If you specify ``GroupName`` , you can't specify ``GroupId`` .
            :param host_id: The ID of the Dedicated Host on which the instance resides. This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ or `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ .
            :param host_resource_group_arn: The ARN of the host resource group in which to launch the instances. If you specify this parameter, either omit the *Tenancy* parameter or set it to ``host`` . This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .
            :param partition_number: The number of the partition that the instance is in. Valid only if the placement group strategy is set to ``partition`` . This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .
            :param spread_domain: Reserved for future use.
            :param tenancy: The tenancy of the instance. An instance with a tenancy of ``dedicated`` runs on single-tenant hardware. This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ . The ``host`` tenancy is not supported for `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ or for T3 instances that are configured for the ``unlimited`` CPU credit option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                placement_property = ec2.CfnEC2Fleet.PlacementProperty(
                    affinity="affinity",
                    availability_zone="availabilityZone",
                    group_name="groupName",
                    host_id="hostId",
                    host_resource_group_arn="hostResourceGroupArn",
                    partition_number=123,
                    spread_domain="spreadDomain",
                    tenancy="tenancy"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__28c598518bf40690e18af7409981451456cd4d41d853891f648b55488b7113f5)
                check_type(argname="argument affinity", value=affinity, expected_type=type_hints["affinity"])
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
                check_type(argname="argument host_id", value=host_id, expected_type=type_hints["host_id"])
                check_type(argname="argument host_resource_group_arn", value=host_resource_group_arn, expected_type=type_hints["host_resource_group_arn"])
                check_type(argname="argument partition_number", value=partition_number, expected_type=type_hints["partition_number"])
                check_type(argname="argument spread_domain", value=spread_domain, expected_type=type_hints["spread_domain"])
                check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if affinity is not None:
                self._values["affinity"] = affinity
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if group_name is not None:
                self._values["group_name"] = group_name
            if host_id is not None:
                self._values["host_id"] = host_id
            if host_resource_group_arn is not None:
                self._values["host_resource_group_arn"] = host_resource_group_arn
            if partition_number is not None:
                self._values["partition_number"] = partition_number
            if spread_domain is not None:
                self._values["spread_domain"] = spread_domain
            if tenancy is not None:
                self._values["tenancy"] = tenancy

        @builtins.property
        def affinity(self) -> typing.Optional[builtins.str]:
            '''The affinity setting for the instance on the Dedicated Host.

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ or `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-affinity
            '''
            result = self._values.get("affinity")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone of the instance.

            If not specified, an Availability Zone will be automatically chosen for you based on the load balancing criteria for the Region.

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def group_name(self) -> typing.Optional[builtins.str]:
            '''The name of the placement group that the instance is in.

            If you specify ``GroupName`` , you can't specify ``GroupId`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-groupname
            '''
            result = self._values.get("group_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def host_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the Dedicated Host on which the instance resides.

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ or `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-hostid
            '''
            result = self._values.get("host_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def host_resource_group_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the host resource group in which to launch the instances.

            If you specify this parameter, either omit the *Tenancy* parameter or set it to ``host`` .

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-hostresourcegrouparn
            '''
            result = self._values.get("host_resource_group_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def partition_number(self) -> typing.Optional[jsii.Number]:
            '''The number of the partition that the instance is in.

            Valid only if the placement group strategy is set to ``partition`` .

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-partitionnumber
            '''
            result = self._values.get("partition_number")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def spread_domain(self) -> typing.Optional[builtins.str]:
            '''Reserved for future use.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-spreaddomain
            '''
            result = self._values.get("spread_domain")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tenancy(self) -> typing.Optional[builtins.str]:
            '''The tenancy of the instance. An instance with a tenancy of ``dedicated`` runs on single-tenant hardware.

            This parameter is not supported for `CreateFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateFleet>`_ . The ``host`` tenancy is not supported for `ImportInstance <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportInstance.html>`_ or for T3 instances that are configured for the ``unlimited`` CPU credit option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-placement.html#cfn-ec2-ec2fleet-placement-tenancy
            '''
            result = self._values.get("tenancy")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PlacementProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.SpotOptionsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "allocation_strategy": "allocationStrategy",
            "instance_interruption_behavior": "instanceInterruptionBehavior",
            "instance_pools_to_use_count": "instancePoolsToUseCount",
            "maintenance_strategies": "maintenanceStrategies",
            "max_total_price": "maxTotalPrice",
            "min_target_capacity": "minTargetCapacity",
            "single_availability_zone": "singleAvailabilityZone",
            "single_instance_type": "singleInstanceType",
        },
    )
    class SpotOptionsRequestProperty:
        def __init__(
            self,
            *,
            allocation_strategy: typing.Optional[builtins.str] = None,
            instance_interruption_behavior: typing.Optional[builtins.str] = None,
            instance_pools_to_use_count: typing.Optional[jsii.Number] = None,
            maintenance_strategies: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.MaintenanceStrategiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            max_total_price: typing.Optional[builtins.str] = None,
            min_target_capacity: typing.Optional[jsii.Number] = None,
            single_availability_zone: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            single_instance_type: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Specifies the configuration of Spot Instances for an EC2 Fleet.

            ``SpotOptionsRequest`` is a property of the `AWS::EC2::EC2Fleet <https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html>`_ resource.

            :param allocation_strategy: Indicates how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the EC2 Fleet. If the allocation strategy is ``lowestPrice`` , EC2 Fleet launches instances from the Spot Instance pools with the lowest price. This is the default allocation strategy. If the allocation strategy is ``diversified`` , EC2 Fleet launches instances from all the Spot Instance pools that you specify. If the allocation strategy is ``capacityOptimized`` , EC2 Fleet launches instances from Spot Instance pools that are optimally chosen based on the available Spot Instance capacity. *Allowed Values* : ``lowestPrice`` | ``diversified`` | ``capacityOptimized`` | ``capacityOptimizedPrioritized``
            :param instance_interruption_behavior: The behavior when a Spot Instance is interrupted. Default: ``terminate``
            :param instance_pools_to_use_count: The number of Spot pools across which to allocate your target Spot capacity. Supported only when Spot ``AllocationStrategy`` is set to ``lowest-price`` . EC2 Fleet selects the cheapest Spot pools and evenly allocates your target Spot capacity across the number of Spot pools that you specify. Note that EC2 Fleet attempts to draw Spot Instances from the number of pools that you specify on a best effort basis. If a pool runs out of Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to fulfill your request by drawing from the next cheapest pool. To ensure that your target capacity is met, you might receive Spot Instances from more than the number of pools that you specified. Similarly, if most of the pools have no Spot capacity, you might receive your full target capacity from fewer than the number of pools that you specified.
            :param maintenance_strategies: The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.
            :param max_total_price: The maximum amount per hour for Spot Instances that you're willing to pay. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter. > If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``MaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``MaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .
            :param min_target_capacity: The minimum target capacity for Spot Instances in the fleet. If the minimum target capacity is not reached, the fleet launches no instances. Supported only for fleets of type ``instant`` . At least one of the following must be specified: ``SingleAvailabilityZone`` | ``SingleInstanceType``
            :param single_availability_zone: Indicates that the fleet launches all Spot Instances into a single Availability Zone. Supported only for fleets of type ``instant`` .
            :param single_instance_type: Indicates that the fleet uses a single instance type to launch all Spot Instances in the fleet. Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_options_request_property = ec2.CfnEC2Fleet.SpotOptionsRequestProperty(
                    allocation_strategy="allocationStrategy",
                    instance_interruption_behavior="instanceInterruptionBehavior",
                    instance_pools_to_use_count=123,
                    maintenance_strategies=ec2.CfnEC2Fleet.MaintenanceStrategiesProperty(
                        capacity_rebalance=ec2.CfnEC2Fleet.CapacityRebalanceProperty(
                            replacement_strategy="replacementStrategy",
                            termination_delay=123
                        )
                    ),
                    max_total_price="maxTotalPrice",
                    min_target_capacity=123,
                    single_availability_zone=False,
                    single_instance_type=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c9673542a949ab3e4b488aaa9dfb67cceabe990e15b2281ccc01f9698538f168)
                check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
                check_type(argname="argument instance_interruption_behavior", value=instance_interruption_behavior, expected_type=type_hints["instance_interruption_behavior"])
                check_type(argname="argument instance_pools_to_use_count", value=instance_pools_to_use_count, expected_type=type_hints["instance_pools_to_use_count"])
                check_type(argname="argument maintenance_strategies", value=maintenance_strategies, expected_type=type_hints["maintenance_strategies"])
                check_type(argname="argument max_total_price", value=max_total_price, expected_type=type_hints["max_total_price"])
                check_type(argname="argument min_target_capacity", value=min_target_capacity, expected_type=type_hints["min_target_capacity"])
                check_type(argname="argument single_availability_zone", value=single_availability_zone, expected_type=type_hints["single_availability_zone"])
                check_type(argname="argument single_instance_type", value=single_instance_type, expected_type=type_hints["single_instance_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if allocation_strategy is not None:
                self._values["allocation_strategy"] = allocation_strategy
            if instance_interruption_behavior is not None:
                self._values["instance_interruption_behavior"] = instance_interruption_behavior
            if instance_pools_to_use_count is not None:
                self._values["instance_pools_to_use_count"] = instance_pools_to_use_count
            if maintenance_strategies is not None:
                self._values["maintenance_strategies"] = maintenance_strategies
            if max_total_price is not None:
                self._values["max_total_price"] = max_total_price
            if min_target_capacity is not None:
                self._values["min_target_capacity"] = min_target_capacity
            if single_availability_zone is not None:
                self._values["single_availability_zone"] = single_availability_zone
            if single_instance_type is not None:
                self._values["single_instance_type"] = single_instance_type

        @builtins.property
        def allocation_strategy(self) -> typing.Optional[builtins.str]:
            '''Indicates how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the EC2 Fleet.

            If the allocation strategy is ``lowestPrice`` , EC2 Fleet launches instances from the Spot Instance pools with the lowest price. This is the default allocation strategy.

            If the allocation strategy is ``diversified`` , EC2 Fleet launches instances from all the Spot Instance pools that you specify.

            If the allocation strategy is ``capacityOptimized`` , EC2 Fleet launches instances from Spot Instance pools that are optimally chosen based on the available Spot Instance capacity.

            *Allowed Values* : ``lowestPrice`` | ``diversified`` | ``capacityOptimized`` | ``capacityOptimizedPrioritized``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-allocationstrategy
            '''
            result = self._values.get("allocation_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_interruption_behavior(self) -> typing.Optional[builtins.str]:
            '''The behavior when a Spot Instance is interrupted.

            Default: ``terminate``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-instanceinterruptionbehavior
            '''
            result = self._values.get("instance_interruption_behavior")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_pools_to_use_count(self) -> typing.Optional[jsii.Number]:
            '''The number of Spot pools across which to allocate your target Spot capacity.

            Supported only when Spot ``AllocationStrategy`` is set to ``lowest-price`` . EC2 Fleet selects the cheapest Spot pools and evenly allocates your target Spot capacity across the number of Spot pools that you specify.

            Note that EC2 Fleet attempts to draw Spot Instances from the number of pools that you specify on a best effort basis. If a pool runs out of Spot capacity before fulfilling your target capacity, EC2 Fleet will continue to fulfill your request by drawing from the next cheapest pool. To ensure that your target capacity is met, you might receive Spot Instances from more than the number of pools that you specified. Similarly, if most of the pools have no Spot capacity, you might receive your full target capacity from fewer than the number of pools that you specified.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-instancepoolstousecount
            '''
            result = self._values.get("instance_pools_to_use_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def maintenance_strategies(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MaintenanceStrategiesProperty"]]:
            '''The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-maintenancestrategies
            '''
            result = self._values.get("maintenance_strategies")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.MaintenanceStrategiesProperty"]], result)

        @builtins.property
        def max_total_price(self) -> typing.Optional[builtins.str]:
            '''The maximum amount per hour for Spot Instances that you're willing to pay.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter. > If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``MaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``MaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-maxtotalprice
            '''
            result = self._values.get("max_total_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def min_target_capacity(self) -> typing.Optional[jsii.Number]:
            '''The minimum target capacity for Spot Instances in the fleet.

            If the minimum target capacity is not reached, the fleet launches no instances.

            Supported only for fleets of type ``instant`` .

            At least one of the following must be specified: ``SingleAvailabilityZone`` | ``SingleInstanceType``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-mintargetcapacity
            '''
            result = self._values.get("min_target_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def single_availability_zone(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates that the fleet launches all Spot Instances into a single Availability Zone.

            Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-singleavailabilityzone
            '''
            result = self._values.get("single_availability_zone")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def single_instance_type(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates that the fleet uses a single instance type to launch all Spot Instances in the fleet.

            Supported only for fleets of type ``instant`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-spotoptionsrequest.html#cfn-ec2-ec2fleet-spotoptionsrequest-singleinstancetype
            '''
            result = self._values.get("single_instance_type")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotOptionsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.TagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class TagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies the tags to apply to a resource when the resource is being created for an EC2 Fleet.

            ``TagSpecification`` is a property of the `AWS::EC2::EC2Fleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html>`_ resource.

            :param resource_type: The type of resource to tag.
            :param tags: The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-tagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                tag_specification_property = ec2.CfnEC2Fleet.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__02540c2eeb5628d16d697845e0771b23c9a778ebfa08c4658341538bee2de664)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource to tag.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-tagspecification.html#cfn-ec2-ec2fleet-tagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-tagspecification.html#cfn-ec2-ec2fleet-tagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.TargetCapacitySpecificationRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "total_target_capacity": "totalTargetCapacity",
            "default_target_capacity_type": "defaultTargetCapacityType",
            "on_demand_target_capacity": "onDemandTargetCapacity",
            "spot_target_capacity": "spotTargetCapacity",
            "target_capacity_unit_type": "targetCapacityUnitType",
        },
    )
    class TargetCapacitySpecificationRequestProperty:
        def __init__(
            self,
            *,
            total_target_capacity: jsii.Number,
            default_target_capacity_type: typing.Optional[builtins.str] = None,
            on_demand_target_capacity: typing.Optional[jsii.Number] = None,
            spot_target_capacity: typing.Optional[jsii.Number] = None,
            target_capacity_unit_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the number of units to request for an EC2 Fleet.

            You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is ``maintain`` , you can specify a target capacity of ``0`` and add capacity later.

            ``TargetCapacitySpecificationRequest`` is a property of the `AWS::EC2::EC2Fleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html>`_ resource.

            :param total_target_capacity: The number of units to request, filled using the default target capacity type.
            :param default_target_capacity_type: The default target capacity type.
            :param on_demand_target_capacity: The number of On-Demand units to request.
            :param spot_target_capacity: The number of Spot units to request.
            :param target_capacity_unit_type: The unit for the target capacity. You can specify this parameter only when using attributed-based instance type selection. Default: ``units`` (the number of instances)

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                target_capacity_specification_request_property = ec2.CfnEC2Fleet.TargetCapacitySpecificationRequestProperty(
                    total_target_capacity=123,
                
                    # the properties below are optional
                    default_target_capacity_type="defaultTargetCapacityType",
                    on_demand_target_capacity=123,
                    spot_target_capacity=123,
                    target_capacity_unit_type="targetCapacityUnitType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ffe51592d5662fcf623b04b7a62a1d91a35fb6ebea29d504ba00fa1b4e924887)
                check_type(argname="argument total_target_capacity", value=total_target_capacity, expected_type=type_hints["total_target_capacity"])
                check_type(argname="argument default_target_capacity_type", value=default_target_capacity_type, expected_type=type_hints["default_target_capacity_type"])
                check_type(argname="argument on_demand_target_capacity", value=on_demand_target_capacity, expected_type=type_hints["on_demand_target_capacity"])
                check_type(argname="argument spot_target_capacity", value=spot_target_capacity, expected_type=type_hints["spot_target_capacity"])
                check_type(argname="argument target_capacity_unit_type", value=target_capacity_unit_type, expected_type=type_hints["target_capacity_unit_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "total_target_capacity": total_target_capacity,
            }
            if default_target_capacity_type is not None:
                self._values["default_target_capacity_type"] = default_target_capacity_type
            if on_demand_target_capacity is not None:
                self._values["on_demand_target_capacity"] = on_demand_target_capacity
            if spot_target_capacity is not None:
                self._values["spot_target_capacity"] = spot_target_capacity
            if target_capacity_unit_type is not None:
                self._values["target_capacity_unit_type"] = target_capacity_unit_type

        @builtins.property
        def total_target_capacity(self) -> jsii.Number:
            '''The number of units to request, filled using the default target capacity type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html#cfn-ec2-ec2fleet-targetcapacityspecificationrequest-totaltargetcapacity
            '''
            result = self._values.get("total_target_capacity")
            assert result is not None, "Required property 'total_target_capacity' is missing"
            return typing.cast(jsii.Number, result)

        @builtins.property
        def default_target_capacity_type(self) -> typing.Optional[builtins.str]:
            '''The default target capacity type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html#cfn-ec2-ec2fleet-targetcapacityspecificationrequest-defaulttargetcapacitytype
            '''
            result = self._values.get("default_target_capacity_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def on_demand_target_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of On-Demand units to request.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html#cfn-ec2-ec2fleet-targetcapacityspecificationrequest-ondemandtargetcapacity
            '''
            result = self._values.get("on_demand_target_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def spot_target_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of Spot units to request.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html#cfn-ec2-ec2fleet-targetcapacityspecificationrequest-spottargetcapacity
            '''
            result = self._values.get("spot_target_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def target_capacity_unit_type(self) -> typing.Optional[builtins.str]:
            '''The unit for the target capacity. You can specify this parameter only when using attributed-based instance type selection.

            Default: ``units`` (the number of instances)

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-targetcapacityspecificationrequest.html#cfn-ec2-ec2fleet-targetcapacityspecificationrequest-targetcapacityunittype
            '''
            result = self._values.get("target_capacity_unit_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TargetCapacitySpecificationRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class TotalLocalStorageGBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total local storage, in GB.

            :param max: The maximum amount of total local storage, in GB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of total local storage, in GB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-totallocalstoragegbrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                total_local_storage_gBRequest_property = ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__68dd4f11ba96f8c88ae78d9d9a0bba32f2c60cb68f8364c2a828277864408781)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of total local storage, in GB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-totallocalstoragegbrequest.html#cfn-ec2-ec2fleet-totallocalstoragegbrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of total local storage, in GB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-totallocalstoragegbrequest.html#cfn-ec2-ec2fleet-totallocalstoragegbrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TotalLocalStorageGBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class VCpuCountRangeRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of vCPUs.

            :param max: The maximum number of vCPUs. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of vCPUs. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-vcpucountrangerequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                v_cpu_count_range_request_property = ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c97ef3c582df6d6b2c591c98531be161631a53d0b66f66fe471939622e85fdc5)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of vCPUs.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-vcpucountrangerequest.html#cfn-ec2-ec2fleet-vcpucountrangerequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of vCPUs.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-vcpucountrangerequest.html#cfn-ec2-ec2fleet-vcpucountrangerequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VCpuCountRangeRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnEC2FleetProps",
    jsii_struct_bases=[],
    name_mapping={
        "launch_template_configs": "launchTemplateConfigs",
        "target_capacity_specification": "targetCapacitySpecification",
        "context": "context",
        "excess_capacity_termination_policy": "excessCapacityTerminationPolicy",
        "on_demand_options": "onDemandOptions",
        "replace_unhealthy_instances": "replaceUnhealthyInstances",
        "spot_options": "spotOptions",
        "tag_specifications": "tagSpecifications",
        "terminate_instances_with_expiration": "terminateInstancesWithExpiration",
        "type": "type",
        "valid_from": "validFrom",
        "valid_until": "validUntil",
    },
)
class CfnEC2FleetProps:
    def __init__(
        self,
        *,
        launch_template_configs: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
        target_capacity_specification: typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TargetCapacitySpecificationRequestProperty, typing.Dict[builtins.str, typing.Any]]],
        context: typing.Optional[builtins.str] = None,
        excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
        on_demand_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.OnDemandOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.SpotOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        type: typing.Optional[builtins.str] = None,
        valid_from: typing.Optional[builtins.str] = None,
        valid_until: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnEC2Fleet``.

        :param launch_template_configs: The configuration for the EC2 Fleet.
        :param target_capacity_specification: The number of units to request.
        :param context: Reserved.
        :param excess_capacity_termination_policy: Indicates whether running instances should be terminated if the total target capacity of the EC2 Fleet is decreased below the current size of the EC2 Fleet. Supported only for fleets of type ``maintain`` .
        :param on_demand_options: Describes the configuration of On-Demand Instances in an EC2 Fleet.
        :param replace_unhealthy_instances: Indicates whether EC2 Fleet should replace unhealthy Spot Instances. Supported only for fleets of type ``maintain`` . For more information, see `EC2 Fleet health checks <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks>`_ in the *Amazon EC2 User Guide* .
        :param spot_options: Describes the configuration of Spot Instances in an EC2 Fleet.
        :param tag_specifications: The key-value pair for tagging the EC2 Fleet request on creation. For more information, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ . If the fleet type is ``instant`` , specify a resource type of ``fleet`` to tag the fleet or ``instance`` to tag the instances at launch. If the fleet type is ``maintain`` or ``request`` , specify a resource type of ``fleet`` to tag the fleet. You cannot specify a resource type of ``instance`` . To tag instances at launch, specify the tags in a `launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ .
        :param terminate_instances_with_expiration: Indicates whether running instances should be terminated when the EC2 Fleet expires.
        :param type: The fleet type. The default value is ``maintain`` . - ``maintain`` - The EC2 Fleet places an asynchronous request for your desired capacity, and continues to maintain your desired Spot capacity by replenishing interrupted Spot Instances. - ``request`` - The EC2 Fleet places an asynchronous one-time request for your desired capacity, but does submit Spot requests in alternative capacity pools if Spot capacity is unavailable, and does not maintain Spot capacity if Spot Instances are interrupted. - ``instant`` - The EC2 Fleet places a synchronous one-time request for your desired capacity, and returns errors for any instances that could not be launched. For more information, see `EC2 Fleet request types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html>`_ in the *Amazon EC2 User Guide* .
        :param valid_from: The start date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). The default is to start fulfilling the request immediately.
        :param valid_until: The end date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). At this point, no new EC2 Fleet requests are placed or able to fulfill the request. If no value is specified, the request remains until you cancel it.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_eC2_fleet_props = ec2.CfnEC2FleetProps(
                launch_template_configs=[ec2.CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty(
                    launch_template_specification=ec2.CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty(
                        version="version",
            
                        # the properties below are optional
                        launch_template_id="launchTemplateId",
                        launch_template_name="launchTemplateName"
                    ),
                    overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                        availability_zone="availabilityZone",
                        instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnEC2Fleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnEC2Fleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnEC2Fleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnEC2Fleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        max_price="maxPrice",
                        placement=ec2.CfnEC2Fleet.PlacementProperty(
                            affinity="affinity",
                            availability_zone="availabilityZone",
                            group_name="groupName",
                            host_id="hostId",
                            host_resource_group_arn="hostResourceGroupArn",
                            partition_number=123,
                            spread_domain="spreadDomain",
                            tenancy="tenancy"
                        ),
                        priority=123,
                        subnet_id="subnetId",
                        weighted_capacity=123
                    )]
                )],
                target_capacity_specification=ec2.CfnEC2Fleet.TargetCapacitySpecificationRequestProperty(
                    total_target_capacity=123,
            
                    # the properties below are optional
                    default_target_capacity_type="defaultTargetCapacityType",
                    on_demand_target_capacity=123,
                    spot_target_capacity=123,
                    target_capacity_unit_type="targetCapacityUnitType"
                ),
            
                # the properties below are optional
                context="context",
                excess_capacity_termination_policy="excessCapacityTerminationPolicy",
                on_demand_options=ec2.CfnEC2Fleet.OnDemandOptionsRequestProperty(
                    allocation_strategy="allocationStrategy",
                    capacity_reservation_options=ec2.CfnEC2Fleet.CapacityReservationOptionsRequestProperty(
                        usage_strategy="usageStrategy"
                    ),
                    max_total_price="maxTotalPrice",
                    min_target_capacity=123,
                    single_availability_zone=False,
                    single_instance_type=False
                ),
                replace_unhealthy_instances=False,
                spot_options=ec2.CfnEC2Fleet.SpotOptionsRequestProperty(
                    allocation_strategy="allocationStrategy",
                    instance_interruption_behavior="instanceInterruptionBehavior",
                    instance_pools_to_use_count=123,
                    maintenance_strategies=ec2.CfnEC2Fleet.MaintenanceStrategiesProperty(
                        capacity_rebalance=ec2.CfnEC2Fleet.CapacityRebalanceProperty(
                            replacement_strategy="replacementStrategy",
                            termination_delay=123
                        )
                    ),
                    max_total_price="maxTotalPrice",
                    min_target_capacity=123,
                    single_availability_zone=False,
                    single_instance_type=False
                ),
                tag_specifications=[ec2.CfnEC2Fleet.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )],
                terminate_instances_with_expiration=False,
                type="type",
                valid_from="validFrom",
                valid_until="validUntil"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7cf6835c4eccb4808ebe4e3b9b155d296d115ff66f1472a19acccd9978a85f7e)
            check_type(argname="argument launch_template_configs", value=launch_template_configs, expected_type=type_hints["launch_template_configs"])
            check_type(argname="argument target_capacity_specification", value=target_capacity_specification, expected_type=type_hints["target_capacity_specification"])
            check_type(argname="argument context", value=context, expected_type=type_hints["context"])
            check_type(argname="argument excess_capacity_termination_policy", value=excess_capacity_termination_policy, expected_type=type_hints["excess_capacity_termination_policy"])
            check_type(argname="argument on_demand_options", value=on_demand_options, expected_type=type_hints["on_demand_options"])
            check_type(argname="argument replace_unhealthy_instances", value=replace_unhealthy_instances, expected_type=type_hints["replace_unhealthy_instances"])
            check_type(argname="argument spot_options", value=spot_options, expected_type=type_hints["spot_options"])
            check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
            check_type(argname="argument terminate_instances_with_expiration", value=terminate_instances_with_expiration, expected_type=type_hints["terminate_instances_with_expiration"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument valid_from", value=valid_from, expected_type=type_hints["valid_from"])
            check_type(argname="argument valid_until", value=valid_until, expected_type=type_hints["valid_until"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "launch_template_configs": launch_template_configs,
            "target_capacity_specification": target_capacity_specification,
        }
        if context is not None:
            self._values["context"] = context
        if excess_capacity_termination_policy is not None:
            self._values["excess_capacity_termination_policy"] = excess_capacity_termination_policy
        if on_demand_options is not None:
            self._values["on_demand_options"] = on_demand_options
        if replace_unhealthy_instances is not None:
            self._values["replace_unhealthy_instances"] = replace_unhealthy_instances
        if spot_options is not None:
            self._values["spot_options"] = spot_options
        if tag_specifications is not None:
            self._values["tag_specifications"] = tag_specifications
        if terminate_instances_with_expiration is not None:
            self._values["terminate_instances_with_expiration"] = terminate_instances_with_expiration
        if type is not None:
            self._values["type"] = type
        if valid_from is not None:
            self._values["valid_from"] = valid_from
        if valid_until is not None:
            self._values["valid_until"] = valid_until

    @builtins.property
    def launch_template_configs(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty]]]:
        '''The configuration for the EC2 Fleet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-launchtemplateconfigs
        '''
        result = self._values.get("launch_template_configs")
        assert result is not None, "Required property 'launch_template_configs' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty]]], result)

    @builtins.property
    def target_capacity_specification(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TargetCapacitySpecificationRequestProperty]:
        '''The number of units to request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-targetcapacityspecification
        '''
        result = self._values.get("target_capacity_specification")
        assert result is not None, "Required property 'target_capacity_specification' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TargetCapacitySpecificationRequestProperty], result)

    @builtins.property
    def context(self) -> typing.Optional[builtins.str]:
        '''Reserved.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-context
        '''
        result = self._values.get("context")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def excess_capacity_termination_policy(self) -> typing.Optional[builtins.str]:
        '''Indicates whether running instances should be terminated if the total target capacity of the EC2 Fleet is decreased below the current size of the EC2 Fleet.

        Supported only for fleets of type ``maintain`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-excesscapacityterminationpolicy
        '''
        result = self._values.get("excess_capacity_termination_policy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def on_demand_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.OnDemandOptionsRequestProperty]]:
        '''Describes the configuration of On-Demand Instances in an EC2 Fleet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-ondemandoptions
        '''
        result = self._values.get("on_demand_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.OnDemandOptionsRequestProperty]], result)

    @builtins.property
    def replace_unhealthy_instances(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether EC2 Fleet should replace unhealthy Spot Instances.

        Supported only for fleets of type ``maintain`` . For more information, see `EC2 Fleet health checks <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#ec2-fleet-health-checks>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-replaceunhealthyinstances
        '''
        result = self._values.get("replace_unhealthy_instances")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def spot_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.SpotOptionsRequestProperty]]:
        '''Describes the configuration of Spot Instances in an EC2 Fleet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-spotoptions
        '''
        result = self._values.get("spot_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.SpotOptionsRequestProperty]], result)

    @builtins.property
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TagSpecificationProperty]]]]:
        '''The key-value pair for tagging the EC2 Fleet request on creation. For more information, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ .

        If the fleet type is ``instant`` , specify a resource type of ``fleet`` to tag the fleet or ``instance`` to tag the instances at launch.

        If the fleet type is ``maintain`` or ``request`` , specify a resource type of ``fleet`` to tag the fleet. You cannot specify a resource type of ``instance`` . To tag instances at launch, specify the tags in a `launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-tagspecifications
        '''
        result = self._values.get("tag_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TagSpecificationProperty]]]], result)

    @builtins.property
    def terminate_instances_with_expiration(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether running instances should be terminated when the EC2 Fleet expires.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-terminateinstanceswithexpiration
        '''
        result = self._values.get("terminate_instances_with_expiration")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def type(self) -> typing.Optional[builtins.str]:
        '''The fleet type. The default value is ``maintain`` .

        - ``maintain`` - The EC2 Fleet places an asynchronous request for your desired capacity, and continues to maintain your desired Spot capacity by replenishing interrupted Spot Instances.
        - ``request`` - The EC2 Fleet places an asynchronous one-time request for your desired capacity, but does submit Spot requests in alternative capacity pools if Spot capacity is unavailable, and does not maintain Spot capacity if Spot Instances are interrupted.
        - ``instant`` - The EC2 Fleet places a synchronous one-time request for your desired capacity, and returns errors for any instances that could not be launched.

        For more information, see `EC2 Fleet request types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-request-type.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-type
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def valid_from(self) -> typing.Optional[builtins.str]:
        '''The start date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).

        The default is to start fulfilling the request immediately.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-validfrom
        '''
        result = self._values.get("valid_from")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def valid_until(self) -> typing.Optional[builtins.str]:
        '''The end date and time of the request, in UTC format (for example, *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).

        At this point, no new EC2 Fleet requests are placed or able to fulfill the request. If no value is specified, the request remains until you cancel it.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ec2fleet.html#cfn-ec2-ec2fleet-validuntil
        '''
        result = self._values.get("valid_until")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnEC2FleetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnEIP(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnEIP",
):
    '''Specifies an Elastic IP (EIP) address and can, optionally, associate it with an Amazon EC2 instance.

    You can allocate an Elastic IP address from an address pool owned by AWS or from an address pool created from a public IPv4 address range that you have brought to AWS for use with your AWS resources using bring your own IP addresses (BYOIP). For more information, see `Bring Your Own IP Addresses (BYOIP) <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html>`_ in the *Amazon EC2 User Guide* .

    For more information, see `Elastic IP Addresses <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html>`_ in the *Amazon EC2 User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html
    :cloudformationResource: AWS::EC2::EIP
    :exampleMetadata: infused

    Example::

        # listener: globalaccelerator.Listener
        # eip: ec2.CfnEIP
        
        
        listener.add_endpoint_group("Group",
            endpoints=[
                ga_endpoints.CfnEipEndpoint(eip,
                    weight=128
                )
            ]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        domain: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        network_border_group: typing.Optional[builtins.str] = None,
        public_ipv4_pool: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transfer_address: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param domain: The network ( ``vpc`` ). If you define an Elastic IP address and associate it with a VPC that is defined in the same template, you must declare a dependency on the VPC-gateway attachment by using the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ on this resource.
        :param instance_id: The ID of the instance. .. epigraph:: Updates to the ``InstanceId`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param network_border_group: A unique set of Availability Zones, Local Zones, or Wavelength Zones from which AWS advertises IP addresses. Use this parameter to limit the IP address to this location. IP addresses cannot move between network border groups. Use `DescribeAvailabilityZones <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html>`_ to view the network border groups.
        :param public_ipv4_pool: The ID of an address pool that you own. Use this parameter to let Amazon EC2 select an address from the address pool. .. epigraph:: Updates to the ``PublicIpv4Pool`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param tags: Any tags assigned to the Elastic IP address. .. epigraph:: Updates to the ``Tags`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param transfer_address: The Elastic IP address you are accepting for transfer. You can only accept one transferred address. For more information on Elastic IP address transfers, see `Transfer Elastic IP addresses <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro>`_ in the *Amazon Virtual Private Cloud User Guide* .
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bccc7dacde749a3ad3c41d116d1f509ffb5b6881668bfa61c205201b19574cf9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnEIPProps(
            domain=domain,
            instance_id=instance_id,
            network_border_group=network_border_group,
            public_ipv4_pool=public_ipv4_pool,
            tags=tags,
            transfer_address=transfer_address,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ff25a50366f77a6df3a4ede4ef39917fc3d769d83828726514086b62d179131)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11eb36186f31c4bea4b03f2dbdc66bc726d4347d12b0636ac6aafbdaf0aaddbe)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAllocationId")
    def attr_allocation_id(self) -> builtins.str:
        '''The ID that AWS assigns to represent the allocation of the address for use with Amazon VPC.

        This is returned only for VPC elastic IP addresses. For example, ``eipalloc-5723d13e`` .

        :cloudformationAttribute: AllocationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAllocationId"))

    @builtins.property
    @jsii.member(jsii_name="attrPublicIp")
    def attr_public_ip(self) -> builtins.str:
        '''The Elastic IP address.

        :cloudformationAttribute: PublicIp
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPublicIp"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="domain")
    def domain(self) -> typing.Optional[builtins.str]:
        '''The network ( ``vpc`` ).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "domain"))

    @domain.setter
    def domain(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c49330fba74ade775140567a6ae48812faa62fb21c67fbdd7930ff5cb2189524)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "domain", value)

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the instance.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceId"))

    @instance_id.setter
    def instance_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca5d5ea7abaea702ac65d5f9e8401058e42e908ac87dfdbb8722dcb03f673d98)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceId", value)

    @builtins.property
    @jsii.member(jsii_name="networkBorderGroup")
    def network_border_group(self) -> typing.Optional[builtins.str]:
        '''A unique set of Availability Zones, Local Zones, or Wavelength Zones from which AWS advertises IP addresses.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkBorderGroup"))

    @network_border_group.setter
    def network_border_group(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ad1782664068283c33182db79bb89a1f93f451785b0dfd4fedeaf0a308110149)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkBorderGroup", value)

    @builtins.property
    @jsii.member(jsii_name="publicIpv4Pool")
    def public_ipv4_pool(self) -> typing.Optional[builtins.str]:
        '''The ID of an address pool that you own.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "publicIpv4Pool"))

    @public_ipv4_pool.setter
    def public_ipv4_pool(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf9bd4708b5d85806a12d49dcb54159d4422fd6d4fea47a05f5f00ece5dca5a6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "publicIpv4Pool", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the Elastic IP address.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3fbabb7ce878301e495e9c01fb2e1183996e3d3ff9174b1398db7c58a5b47c3d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="transferAddress")
    def transfer_address(self) -> typing.Optional[builtins.str]:
        '''The Elastic IP address you are accepting for transfer.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "transferAddress"))

    @transfer_address.setter
    def transfer_address(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__09d9366c0699f2554304df4c739a5801dd39c1ba371b808dcc89894749cd3433)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transferAddress", value)


@jsii.implements(_IInspectable_c2943556)
class CfnEIPAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnEIPAssociation",
):
    '''Associates an Elastic IP address with an instance or a network interface.

    Before you can use an Elastic IP address, you must allocate it to your account. For more information about working with Elastic IP addresses, see `Elastic IP address concepts and rules <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#vpc-eip-overview>`_ .

    You must specify ``AllocationId`` and either ``InstanceId`` , ``NetworkInterfaceId`` , or ``PrivateIpAddress`` .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html
    :cloudformationResource: AWS::EC2::EIPAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_eIPAssociation = ec2.CfnEIPAssociation(self, "MyCfnEIPAssociation",
            allocation_id="allocationId",
            eip="eip",
            instance_id="instanceId",
            network_interface_id="networkInterfaceId",
            private_ip_address="privateIpAddress"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        allocation_id: typing.Optional[builtins.str] = None,
        eip: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param allocation_id: The allocation ID. This is required.
        :param eip: (deprecated) The Elastic IP address to associate with the instance.
        :param instance_id: The ID of the instance. The instance must have exactly one attached network interface. You can specify either the instance ID or the network interface ID, but not both.
        :param network_interface_id: The ID of the network interface. If the instance has more than one network interface, you must specify a network interface ID. You can specify either the instance ID or the network interface ID, but not both.
        :param private_ip_address: The primary or secondary private IP address to associate with the Elastic IP address. If no private IP address is specified, the Elastic IP address is associated with the primary private IP address.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08efa38e3271575d41d7626b99dd3858f0402a0285c2874241829879f80ad5dc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnEIPAssociationProps(
            allocation_id=allocation_id,
            eip=eip,
            instance_id=instance_id,
            network_interface_id=network_interface_id,
            private_ip_address=private_ip_address,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d38ac0f8a89e7add67dbeb5b57090fe5a6fec2abaa2cfa15937784c2f88b46f9)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14b55763d95c0a49faaa7084cf56cd092e1302d037f862850b20fff088532bd2)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the association.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="allocationId")
    def allocation_id(self) -> typing.Optional[builtins.str]:
        '''The allocation ID.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "allocationId"))

    @allocation_id.setter
    def allocation_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a145c0a59ed4b8e109758ede53ea195429ed116afe50bef5519ef1c93ef2f3b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationId", value)

    @builtins.property
    @jsii.member(jsii_name="eip")
    def eip(self) -> typing.Optional[builtins.str]:
        '''(deprecated) The Elastic IP address to associate with the instance.

        :deprecated: this property has been deprecated

        :stability: deprecated
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "eip"))

    @eip.setter
    def eip(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f947c3656e7fb463745cdd982fbd04fbbd2146e52132e6c3c60b88bbf90d3372)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "eip", value)

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the instance.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceId"))

    @instance_id.setter
    def instance_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__15ec06a481e0b7a8566ea8c48543a95bb46df08bdf87da3f3dcba102756d7221)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the network interface.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a3b32138b35250b675dba9ddde0e08a0eb7f077bcd27d5c1bfc7676f3dc799c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="privateIpAddress")
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The primary or secondary private IP address to associate with the Elastic IP address.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "privateIpAddress"))

    @private_ip_address.setter
    def private_ip_address(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0013614294ef24c00fe534d4321fe1657b4fd366c4ea9eccfb2d19b2861d8440)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateIpAddress", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnEIPAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "allocation_id": "allocationId",
        "eip": "eip",
        "instance_id": "instanceId",
        "network_interface_id": "networkInterfaceId",
        "private_ip_address": "privateIpAddress",
    },
)
class CfnEIPAssociationProps:
    def __init__(
        self,
        *,
        allocation_id: typing.Optional[builtins.str] = None,
        eip: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnEIPAssociation``.

        :param allocation_id: The allocation ID. This is required.
        :param eip: (deprecated) The Elastic IP address to associate with the instance.
        :param instance_id: The ID of the instance. The instance must have exactly one attached network interface. You can specify either the instance ID or the network interface ID, but not both.
        :param network_interface_id: The ID of the network interface. If the instance has more than one network interface, you must specify a network interface ID. You can specify either the instance ID or the network interface ID, but not both.
        :param private_ip_address: The primary or secondary private IP address to associate with the Elastic IP address. If no private IP address is specified, the Elastic IP address is associated with the primary private IP address.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_eIPAssociation_props = ec2.CfnEIPAssociationProps(
                allocation_id="allocationId",
                eip="eip",
                instance_id="instanceId",
                network_interface_id="networkInterfaceId",
                private_ip_address="privateIpAddress"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d7e6118721d9f331f2cfafeff3be65471b4d44c1abf5e5083229fa0bb6ad726c)
            check_type(argname="argument allocation_id", value=allocation_id, expected_type=type_hints["allocation_id"])
            check_type(argname="argument eip", value=eip, expected_type=type_hints["eip"])
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if allocation_id is not None:
            self._values["allocation_id"] = allocation_id
        if eip is not None:
            self._values["eip"] = eip
        if instance_id is not None:
            self._values["instance_id"] = instance_id
        if network_interface_id is not None:
            self._values["network_interface_id"] = network_interface_id
        if private_ip_address is not None:
            self._values["private_ip_address"] = private_ip_address

    @builtins.property
    def allocation_id(self) -> typing.Optional[builtins.str]:
        '''The allocation ID.

        This is required.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html#cfn-ec2-eipassociation-allocationid
        '''
        result = self._values.get("allocation_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def eip(self) -> typing.Optional[builtins.str]:
        '''(deprecated) The Elastic IP address to associate with the instance.

        :deprecated: this property has been deprecated

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html#cfn-ec2-eipassociation-eip
        :stability: deprecated
        '''
        result = self._values.get("eip")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the instance.

        The instance must have exactly one attached network interface. You can specify either the instance ID or the network interface ID, but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html#cfn-ec2-eipassociation-instanceid
        '''
        result = self._values.get("instance_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the network interface.

        If the instance has more than one network interface, you must specify a network interface ID.

        You can specify either the instance ID or the network interface ID, but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html#cfn-ec2-eipassociation-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The primary or secondary private IP address to associate with the Elastic IP address.

        If no private IP address is specified, the Elastic IP address is associated with the primary private IP address.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eipassociation.html#cfn-ec2-eipassociation-privateipaddress
        '''
        result = self._values.get("private_ip_address")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnEIPAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnEIPProps",
    jsii_struct_bases=[],
    name_mapping={
        "domain": "domain",
        "instance_id": "instanceId",
        "network_border_group": "networkBorderGroup",
        "public_ipv4_pool": "publicIpv4Pool",
        "tags": "tags",
        "transfer_address": "transferAddress",
    },
)
class CfnEIPProps:
    def __init__(
        self,
        *,
        domain: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        network_border_group: typing.Optional[builtins.str] = None,
        public_ipv4_pool: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transfer_address: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnEIP``.

        :param domain: The network ( ``vpc`` ). If you define an Elastic IP address and associate it with a VPC that is defined in the same template, you must declare a dependency on the VPC-gateway attachment by using the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ on this resource.
        :param instance_id: The ID of the instance. .. epigraph:: Updates to the ``InstanceId`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param network_border_group: A unique set of Availability Zones, Local Zones, or Wavelength Zones from which AWS advertises IP addresses. Use this parameter to limit the IP address to this location. IP addresses cannot move between network border groups. Use `DescribeAvailabilityZones <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html>`_ to view the network border groups.
        :param public_ipv4_pool: The ID of an address pool that you own. Use this parameter to let Amazon EC2 select an address from the address pool. .. epigraph:: Updates to the ``PublicIpv4Pool`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param tags: Any tags assigned to the Elastic IP address. .. epigraph:: Updates to the ``Tags`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.
        :param transfer_address: The Elastic IP address you are accepting for transfer. You can only accept one transferred address. For more information on Elastic IP address transfers, see `Transfer Elastic IP addresses <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro>`_ in the *Amazon Virtual Private Cloud User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html
        :exampleMetadata: infused

        Example::

            # instance: ec2.Instance
            
            # my_zone: route53.HostedZone
            
            
            elastic_ip = ec2.CfnEIP(self, "EIP",
                domain="vpc",
                instance_id=instance.instance_id
            )
            route53.ARecord(self, "ARecord",
                zone=my_zone,
                target=route53.RecordTarget.from_ip_addresses(elastic_ip.ref)
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff96bcb9544d5ebc6273ac8c518468df0cc1fd7720428f6e4ec85ecddb06fa60)
            check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
            check_type(argname="argument network_border_group", value=network_border_group, expected_type=type_hints["network_border_group"])
            check_type(argname="argument public_ipv4_pool", value=public_ipv4_pool, expected_type=type_hints["public_ipv4_pool"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument transfer_address", value=transfer_address, expected_type=type_hints["transfer_address"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if domain is not None:
            self._values["domain"] = domain
        if instance_id is not None:
            self._values["instance_id"] = instance_id
        if network_border_group is not None:
            self._values["network_border_group"] = network_border_group
        if public_ipv4_pool is not None:
            self._values["public_ipv4_pool"] = public_ipv4_pool
        if tags is not None:
            self._values["tags"] = tags
        if transfer_address is not None:
            self._values["transfer_address"] = transfer_address

    @builtins.property
    def domain(self) -> typing.Optional[builtins.str]:
        '''The network ( ``vpc`` ).

        If you define an Elastic IP address and associate it with a VPC that is defined in the same template, you must declare a dependency on the VPC-gateway attachment by using the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ on this resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-domain
        '''
        result = self._values.get("domain")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the instance.

        .. epigraph::

           Updates to the ``InstanceId`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-instanceid
        '''
        result = self._values.get("instance_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_border_group(self) -> typing.Optional[builtins.str]:
        '''A unique set of Availability Zones, Local Zones, or Wavelength Zones from which AWS advertises IP addresses.

        Use this parameter to limit the IP address to this location. IP addresses cannot move between network border groups.

        Use `DescribeAvailabilityZones <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html>`_ to view the network border groups.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-networkbordergroup
        '''
        result = self._values.get("network_border_group")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def public_ipv4_pool(self) -> typing.Optional[builtins.str]:
        '''The ID of an address pool that you own.

        Use this parameter to let Amazon EC2 select an address from the address pool.
        .. epigraph::

           Updates to the ``PublicIpv4Pool`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-publicipv4pool
        '''
        result = self._values.get("public_ipv4_pool")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the Elastic IP address.

        .. epigraph::

           Updates to the ``Tags`` property may require *some interruptions* . Updates on an EIP reassociates the address on its associated resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def transfer_address(self) -> typing.Optional[builtins.str]:
        '''The Elastic IP address you are accepting for transfer.

        You can only accept one transferred address. For more information on Elastic IP address transfers, see `Transfer Elastic IP addresses <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro>`_ in the *Amazon Virtual Private Cloud User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-eip.html#cfn-ec2-eip-transferaddress
        '''
        result = self._values.get("transfer_address")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnEIPProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnEgressOnlyInternetGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnEgressOnlyInternetGateway",
):
    '''[IPv6 only] Specifies an egress-only internet gateway for your VPC.

    An egress-only internet gateway is used to enable outbound communication over IPv6 from instances in your VPC to the internet, and prevents hosts outside of your VPC from initiating an IPv6 connection with your instance.

    For more information, see `Egress-only internet gateway <https://docs.aws.amazon.com/vpc/latest/userguide/egress-only-internet-gateway.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-egressonlyinternetgateway.html
    :cloudformationResource: AWS::EC2::EgressOnlyInternetGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_egress_only_internet_gateway = ec2.CfnEgressOnlyInternetGateway(self, "MyCfnEgressOnlyInternetGateway",
            vpc_id="vpcId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC for which to create the egress-only internet gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84a7ddca98bd1c24713f12588ec54b51cdc19c99c2209e07c964172011c4d7ab)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnEgressOnlyInternetGatewayProps(vpc_id=vpc_id)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3776ca79b4c1077cd8641d4bff766f9377360b8cadb064edee5912829e24521b)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3ac2763e5da89e4e1ee6acf841762d6a8bc01d40589085b652b4f5f545c13102)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the egress-only internet gateway.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC for which to create the egress-only internet gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd41a3676da418b0ac30e8c6707af491b5f32416672bf517e640f6132a942063)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnEgressOnlyInternetGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"vpc_id": "vpcId"},
)
class CfnEgressOnlyInternetGatewayProps:
    def __init__(self, *, vpc_id: builtins.str) -> None:
        '''Properties for defining a ``CfnEgressOnlyInternetGateway``.

        :param vpc_id: The ID of the VPC for which to create the egress-only internet gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-egressonlyinternetgateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_egress_only_internet_gateway_props = ec2.CfnEgressOnlyInternetGatewayProps(
                vpc_id="vpcId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b693b2d49003d73758f4c0003564a93353b18fc97434556a2e988e47f367fb84)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC for which to create the egress-only internet gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-egressonlyinternetgateway.html#cfn-ec2-egressonlyinternetgateway-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnEgressOnlyInternetGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnEnclaveCertificateIamRoleAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnEnclaveCertificateIamRoleAssociation",
):
    '''Associates an AWS Identity and Access Management (IAM) role with an AWS Certificate Manager (ACM) certificate.

    This enables the certificate to be used by the ACM for Nitro Enclaves application inside an enclave. For more information, see `AWS Certificate Manager for Nitro Enclaves <https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html>`_ in the *AWS Nitro Enclaves User Guide* .

    When the IAM role is associated with the ACM certificate, the certificate, certificate chain, and encrypted private key are placed in an Amazon S3 location that only the associated IAM role can access. The private key of the certificate is encrypted with an AWS managed key that has an attached attestation-based key policy.

    To enable the IAM role to access the Amazon S3 object, you must grant it permission to call ``s3:GetObject`` on the Amazon S3 bucket returned by the command. To enable the IAM role to access the KMS key, you must grant it permission to call ``kms:Decrypt`` on the KMS key returned by the command. For more information, see `Grant the role permission to access the certificate and encryption key <https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html#add-policy>`_ in the *AWS Nitro Enclaves User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-enclavecertificateiamroleassociation.html
    :cloudformationResource: AWS::EC2::EnclaveCertificateIamRoleAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_enclave_certificate_iam_role_association = ec2.CfnEnclaveCertificateIamRoleAssociation(self, "MyCfnEnclaveCertificateIamRoleAssociation",
            certificate_arn="certificateArn",
            role_arn="roleArn"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        certificate_arn: builtins.str,
        role_arn: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param certificate_arn: The ARN of the ACM certificate with which to associate the IAM role.
        :param role_arn: The ARN of the IAM role to associate with the ACM certificate. You can associate up to 16 IAM roles with an ACM certificate.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d7cc97af7e0281c5467b107a4b4d0bb76b59e1c397161a6fa7d7f0a2a918097)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnEnclaveCertificateIamRoleAssociationProps(
            certificate_arn=certificate_arn, role_arn=role_arn
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__75c5c30f47a18964a08b0e104af0e125e2c6d69d00e53e23a8faba6e7efb2248)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49fde7f75409bd6c3eef1dc479fe288b3ab71c68799ef372073205fdedd03d81)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCertificateS3BucketName")
    def attr_certificate_s3_bucket_name(self) -> builtins.str:
        '''The name of the Amazon S3 bucket to which the certificate was uploaded.

        :cloudformationAttribute: CertificateS3BucketName
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCertificateS3BucketName"))

    @builtins.property
    @jsii.member(jsii_name="attrCertificateS3ObjectKey")
    def attr_certificate_s3_object_key(self) -> builtins.str:
        '''The Amazon S3 object key where the certificate, certificate chain, and encrypted private key bundle are stored.

        The object key is formatted as follows: ``role_arn`` / ``certificate_arn`` .

        :cloudformationAttribute: CertificateS3ObjectKey
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCertificateS3ObjectKey"))

    @builtins.property
    @jsii.member(jsii_name="attrEncryptionKmsKeyId")
    def attr_encryption_kms_key_id(self) -> builtins.str:
        '''The ID of the AWS KMS key used to encrypt the private key of the certificate.

        :cloudformationAttribute: EncryptionKmsKeyId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrEncryptionKmsKeyId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="certificateArn")
    def certificate_arn(self) -> builtins.str:
        '''The ARN of the ACM certificate with which to associate the IAM role.'''
        return typing.cast(builtins.str, jsii.get(self, "certificateArn"))

    @certificate_arn.setter
    def certificate_arn(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36a9750ebcb712bef33823ecd48c04b607764f04df094442b80cab92b9d24239)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "certificateArn", value)

    @builtins.property
    @jsii.member(jsii_name="roleArn")
    def role_arn(self) -> builtins.str:
        '''The ARN of the IAM role to associate with the ACM certificate.'''
        return typing.cast(builtins.str, jsii.get(self, "roleArn"))

    @role_arn.setter
    def role_arn(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bebb7fefbc76f390f31133552e945be922a94a4a480afe3ae0490c0dad9a102d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "roleArn", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnEnclaveCertificateIamRoleAssociationProps",
    jsii_struct_bases=[],
    name_mapping={"certificate_arn": "certificateArn", "role_arn": "roleArn"},
)
class CfnEnclaveCertificateIamRoleAssociationProps:
    def __init__(
        self,
        *,
        certificate_arn: builtins.str,
        role_arn: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnEnclaveCertificateIamRoleAssociation``.

        :param certificate_arn: The ARN of the ACM certificate with which to associate the IAM role.
        :param role_arn: The ARN of the IAM role to associate with the ACM certificate. You can associate up to 16 IAM roles with an ACM certificate.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-enclavecertificateiamroleassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_enclave_certificate_iam_role_association_props = ec2.CfnEnclaveCertificateIamRoleAssociationProps(
                certificate_arn="certificateArn",
                role_arn="roleArn"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1d46b0b7748b6af77bfec597465bb1c4d453df888f2782e783135feee848f1b)
            check_type(argname="argument certificate_arn", value=certificate_arn, expected_type=type_hints["certificate_arn"])
            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "certificate_arn": certificate_arn,
            "role_arn": role_arn,
        }

    @builtins.property
    def certificate_arn(self) -> builtins.str:
        '''The ARN of the ACM certificate with which to associate the IAM role.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-enclavecertificateiamroleassociation.html#cfn-ec2-enclavecertificateiamroleassociation-certificatearn
        '''
        result = self._values.get("certificate_arn")
        assert result is not None, "Required property 'certificate_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def role_arn(self) -> builtins.str:
        '''The ARN of the IAM role to associate with the ACM certificate.

        You can associate up to 16 IAM roles with an ACM certificate.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-enclavecertificateiamroleassociation.html#cfn-ec2-enclavecertificateiamroleassociation-rolearn
        '''
        result = self._values.get("role_arn")
        assert result is not None, "Required property 'role_arn' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnEnclaveCertificateIamRoleAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnFlowLog(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnFlowLog",
):
    '''Specifies a VPC flow log that captures IP traffic for a specified network interface, subnet, or VPC.

    To view the log data, use Amazon CloudWatch Logs (CloudWatch Logs) to help troubleshoot connection issues. For example, you can use a flow log to investigate why certain traffic isn't reaching an instance, which can help you diagnose overly restrictive security group rules. For more information, see `VPC Flow Logs <https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html
    :cloudformationResource: AWS::EC2::FlowLog
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # destination_options: Any
        
        cfn_flow_log = ec2.CfnFlowLog(self, "MyCfnFlowLog",
            resource_id="resourceId",
            resource_type="resourceType",
        
            # the properties below are optional
            deliver_cross_account_role="deliverCrossAccountRole",
            deliver_logs_permission_arn="deliverLogsPermissionArn",
            destination_options=destination_options,
            log_destination="logDestination",
            log_destination_type="logDestinationType",
            log_format="logFormat",
            log_group_name="logGroupName",
            max_aggregation_interval=123,
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            traffic_type="trafficType"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        resource_id: builtins.str,
        resource_type: builtins.str,
        deliver_cross_account_role: typing.Optional[builtins.str] = None,
        deliver_logs_permission_arn: typing.Optional[builtins.str] = None,
        destination_options: typing.Any = None,
        log_destination: typing.Optional[builtins.str] = None,
        log_destination_type: typing.Optional[builtins.str] = None,
        log_format: typing.Optional[builtins.str] = None,
        log_group_name: typing.Optional[builtins.str] = None,
        max_aggregation_interval: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        traffic_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param resource_id: The ID of the resource to monitor. For example, if the resource type is ``VPC`` , specify the ID of the VPC.
        :param resource_type: The type of resource to monitor.
        :param deliver_cross_account_role: The ARN of the IAM role that allows the service to publish flow logs across accounts.
        :param deliver_logs_permission_arn: The ARN of the IAM role that allows Amazon EC2 to publish flow logs to a CloudWatch Logs log group in your account. This parameter is required if the destination type is ``cloud-watch-logs`` and unsupported otherwise.
        :param destination_options: The destination options. The following options are supported:. - ``FileFormat`` - The format for the flow log ( ``plain-text`` | ``parquet`` ). The default is ``plain-text`` . - ``HiveCompatiblePartitions`` - Indicates whether to use Hive-compatible prefixes for flow logs stored in Amazon S3 ( ``true`` | ``false`` ). The default is ``false`` . - ``PerHourPartition`` - Indicates whether to partition the flow log per hour ( ``true`` | ``false`` ). The default is ``false`` .
        :param log_destination: The destination for the flow log data. The meaning of this parameter depends on the destination type. - If the destination type is ``cloud-watch-logs`` , specify the ARN of a CloudWatch Logs log group. For example: arn:aws:logs: *region* : *account_id* :log-group: *my_group* Alternatively, use the ``LogGroupName`` parameter. - If the destination type is ``s3`` , specify the ARN of an S3 bucket. For example: arn:aws:s3::: *my_bucket* / *my_subfolder* / The subfolder is optional. Note that you can't use ``AWSLogs`` as a subfolder name. - If the destination type is ``kinesis-data-firehose`` , specify the ARN of a Kinesis Data Firehose delivery stream. For example: arn:aws:firehose: *region* : *account_id* :deliverystream: *my_stream*
        :param log_destination_type: The type of destination for the flow log data. Default: ``cloud-watch-logs``
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If you omit this parameter, the flow log is created using the default format. If you specify this parameter, you must include at least one field. For more information about the available fields, see `Flow log records <https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records>`_ in the *Amazon VPC User Guide* or `Transit Gateway Flow Log records <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-flow-logs.html#flow-log-records>`_ in the *AWS Transit Gateway Guide* . Specify the fields using the ``${field-id}`` format, separated by spaces.
        :param log_group_name: The name of a new or existing CloudWatch Logs log group where Amazon EC2 publishes your flow logs. This parameter is valid only if the destination type is ``cloud-watch-logs`` .
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. The possible values are 60 seconds (1 minute) or 600 seconds (10 minutes). This parameter must be 60 seconds for transit gateway resource types. When a network interface is attached to a `Nitro-based instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ , the aggregation interval is always 60 seconds or less, regardless of the value that you specify. Default: 600
        :param tags: The tags to apply to the flow logs.
        :param traffic_type: The type of traffic to monitor (accepted traffic, rejected traffic, or all traffic). This parameter is not supported for transit gateway resource types. It is required for the other resource types.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72358d22276e2eb5cd641ca06942afc99075017aabb8f3000a9b07b53750fcdb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnFlowLogProps(
            resource_id=resource_id,
            resource_type=resource_type,
            deliver_cross_account_role=deliver_cross_account_role,
            deliver_logs_permission_arn=deliver_logs_permission_arn,
            destination_options=destination_options,
            log_destination=log_destination,
            log_destination_type=log_destination_type,
            log_format=log_format,
            log_group_name=log_group_name,
            max_aggregation_interval=max_aggregation_interval,
            tags=tags,
            traffic_type=traffic_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e198443ee858ff19e4aabc024d3248d8cb921d93f5a62465d022de2d8cfa5e2)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6eff7a114e2714334c6df6d1b2e56918a556871696e25a588bf089c4a4ea3f2a)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the flow log.

        For example, ``fl-123456abc123abc1`` .

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="resourceId")
    def resource_id(self) -> builtins.str:
        '''The ID of the resource to monitor.'''
        return typing.cast(builtins.str, jsii.get(self, "resourceId"))

    @resource_id.setter
    def resource_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84e5a2c6ad5e904ca809a2f153ebda2b81c23f9d634700537999ae612f2d8462)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "resourceId", value)

    @builtins.property
    @jsii.member(jsii_name="resourceType")
    def resource_type(self) -> builtins.str:
        '''The type of resource to monitor.'''
        return typing.cast(builtins.str, jsii.get(self, "resourceType"))

    @resource_type.setter
    def resource_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d21f005f9535582c1f46053bf4e82c2bbabff7cded5a69095501539e5f469ff3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "resourceType", value)

    @builtins.property
    @jsii.member(jsii_name="deliverCrossAccountRole")
    def deliver_cross_account_role(self) -> typing.Optional[builtins.str]:
        '''The ARN of the IAM role that allows the service to publish flow logs across accounts.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deliverCrossAccountRole"))

    @deliver_cross_account_role.setter
    def deliver_cross_account_role(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__69de10af6e71879a605a8ff40c4836ff6e89ad4220088a0599668acc26625a53)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deliverCrossAccountRole", value)

    @builtins.property
    @jsii.member(jsii_name="deliverLogsPermissionArn")
    def deliver_logs_permission_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the IAM role that allows Amazon EC2 to publish flow logs to a CloudWatch Logs log group in your account.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deliverLogsPermissionArn"))

    @deliver_logs_permission_arn.setter
    def deliver_logs_permission_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b921f8c4adf8ca7781a1e0174a51a4017191049028a6f93859d3f656946c7c3f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deliverLogsPermissionArn", value)

    @builtins.property
    @jsii.member(jsii_name="destinationOptions")
    def destination_options(self) -> typing.Any:
        '''The destination options.

        The following options are supported:.
        '''
        return typing.cast(typing.Any, jsii.get(self, "destinationOptions"))

    @destination_options.setter
    def destination_options(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49796be537e8b2013810fde10b43929fda215b3a4171af478b31fdb27302d616)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationOptions", value)

    @builtins.property
    @jsii.member(jsii_name="logDestination")
    def log_destination(self) -> typing.Optional[builtins.str]:
        '''The destination for the flow log data.

        The meaning of this parameter depends on the destination type.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "logDestination"))

    @log_destination.setter
    def log_destination(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__949d939e627fcdb6a73a2f76769f6cdfb5973630d761825729685b7af98b27f7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "logDestination", value)

    @builtins.property
    @jsii.member(jsii_name="logDestinationType")
    def log_destination_type(self) -> typing.Optional[builtins.str]:
        '''The type of destination for the flow log data.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "logDestinationType"))

    @log_destination_type.setter
    def log_destination_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce5094d9224f3fc4ab9de0af2048c5229af2bab60296a1532059c7fd0f35152c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "logDestinationType", value)

    @builtins.property
    @jsii.member(jsii_name="logFormat")
    def log_format(self) -> typing.Optional[builtins.str]:
        '''The fields to include in the flow log record, in the order in which they should appear.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "logFormat"))

    @log_format.setter
    def log_format(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c84872a8fa41e81525525e433ae100f134862fcfaf118eb631c2d92ee89fd88)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "logFormat", value)

    @builtins.property
    @jsii.member(jsii_name="logGroupName")
    def log_group_name(self) -> typing.Optional[builtins.str]:
        '''The name of a new or existing CloudWatch Logs log group where Amazon EC2 publishes your flow logs.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "logGroupName"))

    @log_group_name.setter
    def log_group_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d4c0e5979a8d23aa64b8481c35dcd22bd972c3b805f0f16e2bcf9249dd13e78)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "logGroupName", value)

    @builtins.property
    @jsii.member(jsii_name="maxAggregationInterval")
    def max_aggregation_interval(self) -> typing.Optional[jsii.Number]:
        '''The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "maxAggregationInterval"))

    @max_aggregation_interval.setter
    def max_aggregation_interval(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__408957857658c91ed4a24dd2c0001b02c4d953a90495ab29b67a8f47d4c8637d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "maxAggregationInterval", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the flow logs.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d5a7fc9ee55af57fe376f2a1925ca134f75de57ffce411d2318f45b1d139b4a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="trafficType")
    def traffic_type(self) -> typing.Optional[builtins.str]:
        '''The type of traffic to monitor (accepted traffic, rejected traffic, or all traffic).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "trafficType"))

    @traffic_type.setter
    def traffic_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__648073b4921e181f4252118a3f0bd9e0910cc4a9f11632928884f0d6894061ff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trafficType", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnFlowLog.DestinationOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "file_format": "fileFormat",
            "hive_compatible_partitions": "hiveCompatiblePartitions",
            "per_hour_partition": "perHourPartition",
        },
    )
    class DestinationOptionsProperty:
        def __init__(
            self,
            *,
            file_format: builtins.str,
            hive_compatible_partitions: typing.Union[builtins.bool, _IResolvable_da3f097b],
            per_hour_partition: typing.Union[builtins.bool, _IResolvable_da3f097b],
        ) -> None:
            '''Describes the destination options for a flow log.

            :param file_format: The format for the flow log. The default is ``plain-text`` .
            :param hive_compatible_partitions: Indicates whether to use Hive-compatible prefixes for flow logs stored in Amazon S3. The default is ``false`` .
            :param per_hour_partition: Indicates whether to partition the flow log per hour. This reduces the cost and response time for queries. The default is ``false`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-flowlog-destinationoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                destination_options_property = ec2.CfnFlowLog.DestinationOptionsProperty(
                    file_format="fileFormat",
                    hive_compatible_partitions=False,
                    per_hour_partition=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__93145601fe9d5b59646cf267ec0583b6a5749f370d14826d2dc5888efb2826a1)
                check_type(argname="argument file_format", value=file_format, expected_type=type_hints["file_format"])
                check_type(argname="argument hive_compatible_partitions", value=hive_compatible_partitions, expected_type=type_hints["hive_compatible_partitions"])
                check_type(argname="argument per_hour_partition", value=per_hour_partition, expected_type=type_hints["per_hour_partition"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "file_format": file_format,
                "hive_compatible_partitions": hive_compatible_partitions,
                "per_hour_partition": per_hour_partition,
            }

        @builtins.property
        def file_format(self) -> builtins.str:
            '''The format for the flow log.

            The default is ``plain-text`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-flowlog-destinationoptions.html#cfn-ec2-flowlog-destinationoptions-fileformat
            '''
            result = self._values.get("file_format")
            assert result is not None, "Required property 'file_format' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def hive_compatible_partitions(
            self,
        ) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Indicates whether to use Hive-compatible prefixes for flow logs stored in Amazon S3.

            The default is ``false`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-flowlog-destinationoptions.html#cfn-ec2-flowlog-destinationoptions-hivecompatiblepartitions
            '''
            result = self._values.get("hive_compatible_partitions")
            assert result is not None, "Required property 'hive_compatible_partitions' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def per_hour_partition(
            self,
        ) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Indicates whether to partition the flow log per hour.

            This reduces the cost and response time for queries. The default is ``false`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-flowlog-destinationoptions.html#cfn-ec2-flowlog-destinationoptions-perhourpartition
            '''
            result = self._values.get("per_hour_partition")
            assert result is not None, "Required property 'per_hour_partition' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "DestinationOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnFlowLogProps",
    jsii_struct_bases=[],
    name_mapping={
        "resource_id": "resourceId",
        "resource_type": "resourceType",
        "deliver_cross_account_role": "deliverCrossAccountRole",
        "deliver_logs_permission_arn": "deliverLogsPermissionArn",
        "destination_options": "destinationOptions",
        "log_destination": "logDestination",
        "log_destination_type": "logDestinationType",
        "log_format": "logFormat",
        "log_group_name": "logGroupName",
        "max_aggregation_interval": "maxAggregationInterval",
        "tags": "tags",
        "traffic_type": "trafficType",
    },
)
class CfnFlowLogProps:
    def __init__(
        self,
        *,
        resource_id: builtins.str,
        resource_type: builtins.str,
        deliver_cross_account_role: typing.Optional[builtins.str] = None,
        deliver_logs_permission_arn: typing.Optional[builtins.str] = None,
        destination_options: typing.Any = None,
        log_destination: typing.Optional[builtins.str] = None,
        log_destination_type: typing.Optional[builtins.str] = None,
        log_format: typing.Optional[builtins.str] = None,
        log_group_name: typing.Optional[builtins.str] = None,
        max_aggregation_interval: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        traffic_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnFlowLog``.

        :param resource_id: The ID of the resource to monitor. For example, if the resource type is ``VPC`` , specify the ID of the VPC.
        :param resource_type: The type of resource to monitor.
        :param deliver_cross_account_role: The ARN of the IAM role that allows the service to publish flow logs across accounts.
        :param deliver_logs_permission_arn: The ARN of the IAM role that allows Amazon EC2 to publish flow logs to a CloudWatch Logs log group in your account. This parameter is required if the destination type is ``cloud-watch-logs`` and unsupported otherwise.
        :param destination_options: The destination options. The following options are supported:. - ``FileFormat`` - The format for the flow log ( ``plain-text`` | ``parquet`` ). The default is ``plain-text`` . - ``HiveCompatiblePartitions`` - Indicates whether to use Hive-compatible prefixes for flow logs stored in Amazon S3 ( ``true`` | ``false`` ). The default is ``false`` . - ``PerHourPartition`` - Indicates whether to partition the flow log per hour ( ``true`` | ``false`` ). The default is ``false`` .
        :param log_destination: The destination for the flow log data. The meaning of this parameter depends on the destination type. - If the destination type is ``cloud-watch-logs`` , specify the ARN of a CloudWatch Logs log group. For example: arn:aws:logs: *region* : *account_id* :log-group: *my_group* Alternatively, use the ``LogGroupName`` parameter. - If the destination type is ``s3`` , specify the ARN of an S3 bucket. For example: arn:aws:s3::: *my_bucket* / *my_subfolder* / The subfolder is optional. Note that you can't use ``AWSLogs`` as a subfolder name. - If the destination type is ``kinesis-data-firehose`` , specify the ARN of a Kinesis Data Firehose delivery stream. For example: arn:aws:firehose: *region* : *account_id* :deliverystream: *my_stream*
        :param log_destination_type: The type of destination for the flow log data. Default: ``cloud-watch-logs``
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If you omit this parameter, the flow log is created using the default format. If you specify this parameter, you must include at least one field. For more information about the available fields, see `Flow log records <https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records>`_ in the *Amazon VPC User Guide* or `Transit Gateway Flow Log records <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-flow-logs.html#flow-log-records>`_ in the *AWS Transit Gateway Guide* . Specify the fields using the ``${field-id}`` format, separated by spaces.
        :param log_group_name: The name of a new or existing CloudWatch Logs log group where Amazon EC2 publishes your flow logs. This parameter is valid only if the destination type is ``cloud-watch-logs`` .
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. The possible values are 60 seconds (1 minute) or 600 seconds (10 minutes). This parameter must be 60 seconds for transit gateway resource types. When a network interface is attached to a `Nitro-based instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ , the aggregation interval is always 60 seconds or less, regardless of the value that you specify. Default: 600
        :param tags: The tags to apply to the flow logs.
        :param traffic_type: The type of traffic to monitor (accepted traffic, rejected traffic, or all traffic). This parameter is not supported for transit gateway resource types. It is required for the other resource types.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # destination_options: Any
            
            cfn_flow_log_props = ec2.CfnFlowLogProps(
                resource_id="resourceId",
                resource_type="resourceType",
            
                # the properties below are optional
                deliver_cross_account_role="deliverCrossAccountRole",
                deliver_logs_permission_arn="deliverLogsPermissionArn",
                destination_options=destination_options,
                log_destination="logDestination",
                log_destination_type="logDestinationType",
                log_format="logFormat",
                log_group_name="logGroupName",
                max_aggregation_interval=123,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                traffic_type="trafficType"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b70808589b9adfc66e939b8c87268607775dc0e479da5f4bed72c3ba8e3afef5)
            check_type(argname="argument resource_id", value=resource_id, expected_type=type_hints["resource_id"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            check_type(argname="argument deliver_cross_account_role", value=deliver_cross_account_role, expected_type=type_hints["deliver_cross_account_role"])
            check_type(argname="argument deliver_logs_permission_arn", value=deliver_logs_permission_arn, expected_type=type_hints["deliver_logs_permission_arn"])
            check_type(argname="argument destination_options", value=destination_options, expected_type=type_hints["destination_options"])
            check_type(argname="argument log_destination", value=log_destination, expected_type=type_hints["log_destination"])
            check_type(argname="argument log_destination_type", value=log_destination_type, expected_type=type_hints["log_destination_type"])
            check_type(argname="argument log_format", value=log_format, expected_type=type_hints["log_format"])
            check_type(argname="argument log_group_name", value=log_group_name, expected_type=type_hints["log_group_name"])
            check_type(argname="argument max_aggregation_interval", value=max_aggregation_interval, expected_type=type_hints["max_aggregation_interval"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument traffic_type", value=traffic_type, expected_type=type_hints["traffic_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "resource_id": resource_id,
            "resource_type": resource_type,
        }
        if deliver_cross_account_role is not None:
            self._values["deliver_cross_account_role"] = deliver_cross_account_role
        if deliver_logs_permission_arn is not None:
            self._values["deliver_logs_permission_arn"] = deliver_logs_permission_arn
        if destination_options is not None:
            self._values["destination_options"] = destination_options
        if log_destination is not None:
            self._values["log_destination"] = log_destination
        if log_destination_type is not None:
            self._values["log_destination_type"] = log_destination_type
        if log_format is not None:
            self._values["log_format"] = log_format
        if log_group_name is not None:
            self._values["log_group_name"] = log_group_name
        if max_aggregation_interval is not None:
            self._values["max_aggregation_interval"] = max_aggregation_interval
        if tags is not None:
            self._values["tags"] = tags
        if traffic_type is not None:
            self._values["traffic_type"] = traffic_type

    @builtins.property
    def resource_id(self) -> builtins.str:
        '''The ID of the resource to monitor.

        For example, if the resource type is ``VPC`` , specify the ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-resourceid
        '''
        result = self._values.get("resource_id")
        assert result is not None, "Required property 'resource_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def resource_type(self) -> builtins.str:
        '''The type of resource to monitor.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-resourcetype
        '''
        result = self._values.get("resource_type")
        assert result is not None, "Required property 'resource_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def deliver_cross_account_role(self) -> typing.Optional[builtins.str]:
        '''The ARN of the IAM role that allows the service to publish flow logs across accounts.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-delivercrossaccountrole
        '''
        result = self._values.get("deliver_cross_account_role")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def deliver_logs_permission_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the IAM role that allows Amazon EC2 to publish flow logs to a CloudWatch Logs log group in your account.

        This parameter is required if the destination type is ``cloud-watch-logs`` and unsupported otherwise.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-deliverlogspermissionarn
        '''
        result = self._values.get("deliver_logs_permission_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_options(self) -> typing.Any:
        '''The destination options. The following options are supported:.

        - ``FileFormat`` - The format for the flow log ( ``plain-text`` | ``parquet`` ). The default is ``plain-text`` .
        - ``HiveCompatiblePartitions`` - Indicates whether to use Hive-compatible prefixes for flow logs stored in Amazon S3 ( ``true`` | ``false`` ). The default is ``false`` .
        - ``PerHourPartition`` - Indicates whether to partition the flow log per hour ( ``true`` | ``false`` ). The default is ``false`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-destinationoptions
        '''
        result = self._values.get("destination_options")
        return typing.cast(typing.Any, result)

    @builtins.property
    def log_destination(self) -> typing.Optional[builtins.str]:
        '''The destination for the flow log data. The meaning of this parameter depends on the destination type.

        - If the destination type is ``cloud-watch-logs`` , specify the ARN of a CloudWatch Logs log group. For example:

        arn:aws:logs: *region* : *account_id* :log-group: *my_group*

        Alternatively, use the ``LogGroupName`` parameter.

        - If the destination type is ``s3`` , specify the ARN of an S3 bucket. For example:

        arn:aws:s3::: *my_bucket* / *my_subfolder* /

        The subfolder is optional. Note that you can't use ``AWSLogs`` as a subfolder name.

        - If the destination type is ``kinesis-data-firehose`` , specify the ARN of a Kinesis Data Firehose delivery stream. For example:

        arn:aws:firehose: *region* : *account_id* :deliverystream: *my_stream*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-logdestination
        '''
        result = self._values.get("log_destination")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_destination_type(self) -> typing.Optional[builtins.str]:
        '''The type of destination for the flow log data.

        Default: ``cloud-watch-logs``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-logdestinationtype
        '''
        result = self._values.get("log_destination_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_format(self) -> typing.Optional[builtins.str]:
        '''The fields to include in the flow log record, in the order in which they should appear.

        If you omit this parameter, the flow log is created using the default format. If you specify this parameter, you must include at least one field. For more information about the available fields, see `Flow log records <https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records>`_ in the *Amazon VPC User Guide* or `Transit Gateway Flow Log records <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-flow-logs.html#flow-log-records>`_ in the *AWS Transit Gateway Guide* .

        Specify the fields using the ``${field-id}`` format, separated by spaces.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-logformat
        '''
        result = self._values.get("log_format")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_group_name(self) -> typing.Optional[builtins.str]:
        '''The name of a new or existing CloudWatch Logs log group where Amazon EC2 publishes your flow logs.

        This parameter is valid only if the destination type is ``cloud-watch-logs`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-loggroupname
        '''
        result = self._values.get("log_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_aggregation_interval(self) -> typing.Optional[jsii.Number]:
        '''The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record.

        The possible values are 60 seconds (1 minute) or 600 seconds (10 minutes). This parameter must be 60 seconds for transit gateway resource types.

        When a network interface is attached to a `Nitro-based instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ , the aggregation interval is always 60 seconds or less, regardless of the value that you specify.

        Default: 600

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-maxaggregationinterval
        '''
        result = self._values.get("max_aggregation_interval")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the flow logs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def traffic_type(self) -> typing.Optional[builtins.str]:
        '''The type of traffic to monitor (accepted traffic, rejected traffic, or all traffic).

        This parameter is not supported for transit gateway resource types. It is required for the other resource types.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-traffictype
        '''
        result = self._values.get("traffic_type")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnFlowLogProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnGatewayRouteTableAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnGatewayRouteTableAssociation",
):
    '''Associates a virtual private gateway or internet gateway with a route table.

    The gateway and route table must be in the same VPC. This association causes the incoming traffic to the gateway to be routed according to the routes in the route table.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-gatewayroutetableassociation.html
    :cloudformationResource: AWS::EC2::GatewayRouteTableAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_gateway_route_table_association = ec2.CfnGatewayRouteTableAssociation(self, "MyCfnGatewayRouteTableAssociation",
            gateway_id="gatewayId",
            route_table_id="routeTableId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        gateway_id: builtins.str,
        route_table_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param gateway_id: The ID of the gateway.
        :param route_table_id: The ID of the route table.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b6e9c558b84db03ce7f87c5229b1660a182dbcc83eb7b603939ad024b053290)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnGatewayRouteTableAssociationProps(
            gateway_id=gateway_id, route_table_id=route_table_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__210fd654bd3dbc467b26765ed18c099ae7b5043c293d926cade19fd3802bd80f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b18f652516d55efdc0bbaf9e0aed3e5e7b9ed6a627018605ad3a8ac40bcfb08)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAssociationId")
    def attr_association_id(self) -> builtins.str:
        '''The ID of the route table association.

        :cloudformationAttribute: AssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="gatewayId")
    def gateway_id(self) -> builtins.str:
        '''The ID of the gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "gatewayId"))

    @gateway_id.setter
    def gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b80b9e3979b7f3bc56f10b10d915c83ac792f4ea63ad245c84317b275a65523d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "gatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="routeTableId")
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table.'''
        return typing.cast(builtins.str, jsii.get(self, "routeTableId"))

    @route_table_id.setter
    def route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9de1cff2e9acdaccf461af9bb29e1e72246de3e47124324639ada6d2b19a81f4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "routeTableId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnGatewayRouteTableAssociationProps",
    jsii_struct_bases=[],
    name_mapping={"gateway_id": "gatewayId", "route_table_id": "routeTableId"},
)
class CfnGatewayRouteTableAssociationProps:
    def __init__(
        self,
        *,
        gateway_id: builtins.str,
        route_table_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnGatewayRouteTableAssociation``.

        :param gateway_id: The ID of the gateway.
        :param route_table_id: The ID of the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-gatewayroutetableassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_gateway_route_table_association_props = ec2.CfnGatewayRouteTableAssociationProps(
                gateway_id="gatewayId",
                route_table_id="routeTableId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__17bdeaef71282588c502b071ec9708033fec42cd59c61e718eb5899520703999)
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "gateway_id": gateway_id,
            "route_table_id": route_table_id,
        }

    @builtins.property
    def gateway_id(self) -> builtins.str:
        '''The ID of the gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-gatewayroutetableassociation.html#cfn-ec2-gatewayroutetableassociation-gatewayid
        '''
        result = self._values.get("gateway_id")
        assert result is not None, "Required property 'gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-gatewayroutetableassociation.html#cfn-ec2-gatewayroutetableassociation-routetableid
        '''
        result = self._values.get("route_table_id")
        assert result is not None, "Required property 'route_table_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnGatewayRouteTableAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnHost(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnHost",
):
    '''Allocates a fully dedicated physical server for launching EC2 instances.

    Because the host is fully dedicated for your use, it can help you address compliance requirements and reduce costs by allowing you to use your existing server-bound software licenses. For more information, see `Dedicated Hosts <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html
    :cloudformationResource: AWS::EC2::Host
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_host = ec2.CfnHost(self, "MyCfnHost",
            availability_zone="availabilityZone",
        
            # the properties below are optional
            asset_id="assetId",
            auto_placement="autoPlacement",
            host_maintenance="hostMaintenance",
            host_recovery="hostRecovery",
            instance_family="instanceFamily",
            instance_type="instanceType",
            outpost_arn="outpostArn"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        asset_id: typing.Optional[builtins.str] = None,
        auto_placement: typing.Optional[builtins.str] = None,
        host_maintenance: typing.Optional[builtins.str] = None,
        host_recovery: typing.Optional[builtins.str] = None,
        instance_family: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional[builtins.str] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param availability_zone: The Availability Zone in which to allocate the Dedicated Host.
        :param asset_id: The ID of the Outpost hardware asset on which the Dedicated Host is allocated.
        :param auto_placement: Indicates whether the host accepts any untargeted instance launches that match its instance type configuration, or if it only accepts Host tenancy instance launches that specify its unique host ID. For more information, see `Understanding auto-placement and affinity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-dedicated-hosts-work.html#dedicated-hosts-understanding>`_ in the *Amazon EC2 User Guide* . Default: ``on``
        :param host_maintenance: Indicates whether host maintenance is enabled or disabled for the Dedicated Host.
        :param host_recovery: Indicates whether to enable or disable host recovery for the Dedicated Host. Host recovery is disabled by default. For more information, see `Host recovery <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-recovery.html>`_ in the *Amazon EC2 User Guide* . Default: ``off``
        :param instance_family: The instance family supported by the Dedicated Host. For example, ``m5`` .
        :param instance_type: Specifies the instance type to be supported by the Dedicated Hosts. If you specify an instance type, the Dedicated Hosts support instances of the specified instance type only.
        :param outpost_arn: The Amazon Resource Name (ARN) of the AWS Outpost on which the Dedicated Host is allocated.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3a07acffdb551edbc817b7c424628c812f21356d7f697757a332323f6dcfde8)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnHostProps(
            availability_zone=availability_zone,
            asset_id=asset_id,
            auto_placement=auto_placement,
            host_maintenance=host_maintenance,
            host_recovery=host_recovery,
            instance_family=instance_family,
            instance_type=instance_type,
            outpost_arn=outpost_arn,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62948130163263864ea13dc24c244d1ba844fcdcbf6e72536422cfe1f035d0ae)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f6d598529fd0d16119fff477306582a339f6d734027d9e85531c72b90654a41)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrHostId")
    def attr_host_id(self) -> builtins.str:
        '''The ID of the host.

        :cloudformationAttribute: HostId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrHostId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone in which to allocate the Dedicated Host.'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @availability_zone.setter
    def availability_zone(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8f2943fd7038584c6a32abc7ac0a93f4b0f4c63881cfa72150bd73ada16642d0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZone", value)

    @builtins.property
    @jsii.member(jsii_name="assetId")
    def asset_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the Outpost hardware asset on which the Dedicated Host is allocated.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "assetId"))

    @asset_id.setter
    def asset_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ef92a5203275a4f9d2ce9835a43f6cd82cac31cb59c1d0ce172cbfc9e50fbefb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "assetId", value)

    @builtins.property
    @jsii.member(jsii_name="autoPlacement")
    def auto_placement(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the host accepts any untargeted instance launches that match its instance type configuration, or if it only accepts Host tenancy instance launches that specify its unique host ID.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "autoPlacement"))

    @auto_placement.setter
    def auto_placement(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__847519b23588450ab8d14c5778b80f32cdf5fa3f1ca8c772c0b129d3a9ad3c32)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "autoPlacement", value)

    @builtins.property
    @jsii.member(jsii_name="hostMaintenance")
    def host_maintenance(self) -> typing.Optional[builtins.str]:
        '''Indicates whether host maintenance is enabled or disabled for the Dedicated Host.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "hostMaintenance"))

    @host_maintenance.setter
    def host_maintenance(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5da78a5d765050694e66dbb10d6bc046deaee511071b83699b9f3c2f2816c2b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "hostMaintenance", value)

    @builtins.property
    @jsii.member(jsii_name="hostRecovery")
    def host_recovery(self) -> typing.Optional[builtins.str]:
        '''Indicates whether to enable or disable host recovery for the Dedicated Host.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "hostRecovery"))

    @host_recovery.setter
    def host_recovery(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b92e78abd69ef3031b103aed1c9826c3000239f5d58022c4cb1dd256f65a8da9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "hostRecovery", value)

    @builtins.property
    @jsii.member(jsii_name="instanceFamily")
    def instance_family(self) -> typing.Optional[builtins.str]:
        '''The instance family supported by the Dedicated Host.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceFamily"))

    @instance_family.setter
    def instance_family(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__17d80a761d1af3dea3988a895a0ef398f8f899481397c0e52127d20797de751e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceFamily", value)

    @builtins.property
    @jsii.member(jsii_name="instanceType")
    def instance_type(self) -> typing.Optional[builtins.str]:
        '''Specifies the instance type to be supported by the Dedicated Hosts.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceType"))

    @instance_type.setter
    def instance_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c99a5cb989b1890ba7a9c45d3bf3f171871e622316f2e23f45489e55fae7586)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceType", value)

    @builtins.property
    @jsii.member(jsii_name="outpostArn")
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the AWS Outpost on which the Dedicated Host is allocated.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "outpostArn"))

    @outpost_arn.setter
    def outpost_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e93e24d3ea88403b39f7d948c7495b074446c1b676d25cd60fc9a3a558e7f36)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "outpostArn", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnHostProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "asset_id": "assetId",
        "auto_placement": "autoPlacement",
        "host_maintenance": "hostMaintenance",
        "host_recovery": "hostRecovery",
        "instance_family": "instanceFamily",
        "instance_type": "instanceType",
        "outpost_arn": "outpostArn",
    },
)
class CfnHostProps:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        asset_id: typing.Optional[builtins.str] = None,
        auto_placement: typing.Optional[builtins.str] = None,
        host_maintenance: typing.Optional[builtins.str] = None,
        host_recovery: typing.Optional[builtins.str] = None,
        instance_family: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional[builtins.str] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnHost``.

        :param availability_zone: The Availability Zone in which to allocate the Dedicated Host.
        :param asset_id: The ID of the Outpost hardware asset on which the Dedicated Host is allocated.
        :param auto_placement: Indicates whether the host accepts any untargeted instance launches that match its instance type configuration, or if it only accepts Host tenancy instance launches that specify its unique host ID. For more information, see `Understanding auto-placement and affinity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-dedicated-hosts-work.html#dedicated-hosts-understanding>`_ in the *Amazon EC2 User Guide* . Default: ``on``
        :param host_maintenance: Indicates whether host maintenance is enabled or disabled for the Dedicated Host.
        :param host_recovery: Indicates whether to enable or disable host recovery for the Dedicated Host. Host recovery is disabled by default. For more information, see `Host recovery <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-recovery.html>`_ in the *Amazon EC2 User Guide* . Default: ``off``
        :param instance_family: The instance family supported by the Dedicated Host. For example, ``m5`` .
        :param instance_type: Specifies the instance type to be supported by the Dedicated Hosts. If you specify an instance type, the Dedicated Hosts support instances of the specified instance type only.
        :param outpost_arn: The Amazon Resource Name (ARN) of the AWS Outpost on which the Dedicated Host is allocated.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_host_props = ec2.CfnHostProps(
                availability_zone="availabilityZone",
            
                # the properties below are optional
                asset_id="assetId",
                auto_placement="autoPlacement",
                host_maintenance="hostMaintenance",
                host_recovery="hostRecovery",
                instance_family="instanceFamily",
                instance_type="instanceType",
                outpost_arn="outpostArn"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6b2753a5bf48a7bda574bdc6bf8ca7f9c31c7e48329df5f793f75cfb822ea308)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument asset_id", value=asset_id, expected_type=type_hints["asset_id"])
            check_type(argname="argument auto_placement", value=auto_placement, expected_type=type_hints["auto_placement"])
            check_type(argname="argument host_maintenance", value=host_maintenance, expected_type=type_hints["host_maintenance"])
            check_type(argname="argument host_recovery", value=host_recovery, expected_type=type_hints["host_recovery"])
            check_type(argname="argument instance_family", value=instance_family, expected_type=type_hints["instance_family"])
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument outpost_arn", value=outpost_arn, expected_type=type_hints["outpost_arn"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
        }
        if asset_id is not None:
            self._values["asset_id"] = asset_id
        if auto_placement is not None:
            self._values["auto_placement"] = auto_placement
        if host_maintenance is not None:
            self._values["host_maintenance"] = host_maintenance
        if host_recovery is not None:
            self._values["host_recovery"] = host_recovery
        if instance_family is not None:
            self._values["instance_family"] = instance_family
        if instance_type is not None:
            self._values["instance_type"] = instance_type
        if outpost_arn is not None:
            self._values["outpost_arn"] = outpost_arn

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone in which to allocate the Dedicated Host.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-availabilityzone
        '''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def asset_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the Outpost hardware asset on which the Dedicated Host is allocated.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-assetid
        '''
        result = self._values.get("asset_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_placement(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the host accepts any untargeted instance launches that match its instance type configuration, or if it only accepts Host tenancy instance launches that specify its unique host ID.

        For more information, see `Understanding auto-placement and affinity <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-dedicated-hosts-work.html#dedicated-hosts-understanding>`_ in the *Amazon EC2 User Guide* .

        Default: ``on``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-autoplacement
        '''
        result = self._values.get("auto_placement")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def host_maintenance(self) -> typing.Optional[builtins.str]:
        '''Indicates whether host maintenance is enabled or disabled for the Dedicated Host.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-hostmaintenance
        '''
        result = self._values.get("host_maintenance")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def host_recovery(self) -> typing.Optional[builtins.str]:
        '''Indicates whether to enable or disable host recovery for the Dedicated Host.

        Host recovery is disabled by default. For more information, see `Host recovery <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-recovery.html>`_ in the *Amazon EC2 User Guide* .

        Default: ``off``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-hostrecovery
        '''
        result = self._values.get("host_recovery")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_family(self) -> typing.Optional[builtins.str]:
        '''The instance family supported by the Dedicated Host.

        For example, ``m5`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-instancefamily
        '''
        result = self._values.get("instance_family")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_type(self) -> typing.Optional[builtins.str]:
        '''Specifies the instance type to be supported by the Dedicated Hosts.

        If you specify an instance type, the Dedicated Hosts support instances of the specified instance type only.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-instancetype
        '''
        result = self._values.get("instance_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the AWS Outpost on which the Dedicated Host is allocated.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-host.html#cfn-ec2-host-outpostarn
        '''
        result = self._values.get("outpost_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnHostProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnIPAM(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAM",
):
    '''IPAM is a VPC feature that you can use to automate your IP address management workflows including assigning, tracking, troubleshooting, and auditing IP addresses across AWS Regions and accounts throughout your AWS Organization.

    For more information, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

    There are AWS Identity and Access Management (IAM) permissions required to fully manage an IPAM in CloudFormation. For more information, see `Example policy <https://docs.aws.amazon.com//vpc/latest/ipam/iam-ipam-policy-examples.html>`_ in the *Amazon VPC IPAM User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html
    :cloudformationResource: AWS::EC2::IPAM
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAM = ec2.CfnIPAM(self, "MyCfnIPAM",
            description="description",
            operating_regions=[ec2.CfnIPAM.IpamOperatingRegionProperty(
                region_name="regionName"
            )],
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            tier="tier"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIPAM.IpamOperatingRegionProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        tier: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param description: The description for the IPAM.
        :param operating_regions: The operating Regions for an IPAM. Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions. For more information about operating Regions, see `Create an IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.
        :param tier: IPAM is offered in a Free Tier and an Advanced Tier. For more information about the features available in each tier and the costs associated with the tiers, see the `VPC IPAM product pricing page <https://docs.aws.amazon.com//vpc/pricing/>`_ .
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5dd8d015864426e689ac2f72f1fdd70371d242931964ab4d571ea56017f00045)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMProps(
            description=description,
            operating_regions=operating_regions,
            tags=tags,
            tier=tier,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52d60de86ca7ba70a9845a22c132a50b0a472c7cce8b00d8e266f850b9c0e6f4)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__901ef9223e06c12f769b4bd36857fd88adae614a05385d54a0dd6f535824d002)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrArn")
    def attr_arn(self) -> builtins.str:
        '''The ARN of the IPAM.

        :cloudformationAttribute: Arn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrArn"))

    @builtins.property
    @jsii.member(jsii_name="attrDefaultResourceDiscoveryAssociationId")
    def attr_default_resource_discovery_association_id(self) -> builtins.str:
        '''The ID of the default resource discovery association.

        :cloudformationAttribute: DefaultResourceDiscoveryAssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDefaultResourceDiscoveryAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="attrDefaultResourceDiscoveryId")
    def attr_default_resource_discovery_id(self) -> builtins.str:
        '''The ID of the default resource discovery.

        :cloudformationAttribute: DefaultResourceDiscoveryId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDefaultResourceDiscoveryId"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamId")
    def attr_ipam_id(self) -> builtins.str:
        '''The ID of the IPAM.

        :cloudformationAttribute: IpamId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamId"))

    @builtins.property
    @jsii.member(jsii_name="attrPrivateDefaultScopeId")
    def attr_private_default_scope_id(self) -> builtins.str:
        '''The ID of the default private scope.

        :cloudformationAttribute: PrivateDefaultScopeId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrivateDefaultScopeId"))

    @builtins.property
    @jsii.member(jsii_name="attrPublicDefaultScopeId")
    def attr_public_default_scope_id(self) -> builtins.str:
        '''The ID of the default public scope.

        :cloudformationAttribute: PublicDefaultScopeId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPublicDefaultScopeId"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceDiscoveryAssociationCount")
    def attr_resource_discovery_association_count(self) -> jsii.Number:
        '''The number of resource discovery associations.

        :cloudformationAttribute: ResourceDiscoveryAssociationCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrResourceDiscoveryAssociationCount"))

    @builtins.property
    @jsii.member(jsii_name="attrScopeCount")
    def attr_scope_count(self) -> jsii.Number:
        '''The number of scopes.

        :cloudformationAttribute: ScopeCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrScopeCount"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description for the IPAM.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__959c716c17871ad25c09c928583239d9973366c81c48b69bfc39c5c2a70898ce)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="operatingRegions")
    def operating_regions(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAM.IpamOperatingRegionProperty"]]]]:
        '''The operating Regions for an IPAM.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAM.IpamOperatingRegionProperty"]]]], jsii.get(self, "operatingRegions"))

    @operating_regions.setter
    def operating_regions(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAM.IpamOperatingRegionProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fecbb17dcfafe289f5a442dc3b73f564f5de07433cc7e26b8e86425af382451f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "operatingRegions", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e1f584e5fc1ac961e5449d71a22aa5c200ae3632e3bd5a9caba51ea5d38dde7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="tier")
    def tier(self) -> typing.Optional[builtins.str]:
        '''IPAM is offered in a Free Tier and an Advanced Tier.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tier"))

    @tier.setter
    def tier(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c8cecf24bfc36bfa727b2bcc8526f504fce30463cb6dcc5d49d5b9d67749d5e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tier", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnIPAM.IpamOperatingRegionProperty",
        jsii_struct_bases=[],
        name_mapping={"region_name": "regionName"},
    )
    class IpamOperatingRegionProperty:
        def __init__(self, *, region_name: builtins.str) -> None:
            '''The operating Regions for an IPAM.

            Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.

            For more information about operating Regions, see `Create an IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

            :param region_name: The name of the operating Region.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipam-ipamoperatingregion.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipam_operating_region_property = ec2.CfnIPAM.IpamOperatingRegionProperty(
                    region_name="regionName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__76ae7ea9478fca86299eafd84b20c22db0b753cea0096278a3be708fdccb0c7d)
                check_type(argname="argument region_name", value=region_name, expected_type=type_hints["region_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "region_name": region_name,
            }

        @builtins.property
        def region_name(self) -> builtins.str:
            '''The name of the operating Region.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipam-ipamoperatingregion.html#cfn-ec2-ipam-ipamoperatingregion-regionname
            '''
            result = self._values.get("region_name")
            assert result is not None, "Required property 'region_name' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IpamOperatingRegionProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnIPAMAllocation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMAllocation",
):
    '''In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool or to a resource.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html
    :cloudformationResource: AWS::EC2::IPAMAllocation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMAllocation = ec2.CfnIPAMAllocation(self, "MyCfnIPAMAllocation",
            ipam_pool_id="ipamPoolId",
        
            # the properties below are optional
            cidr="cidr",
            description="description",
            netmask_length=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ipam_pool_id: builtins.str,
        cidr: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param ipam_pool_id: The ID of the IPAM pool from which you would like to allocate a CIDR.
        :param cidr: The CIDR you would like to allocate from the IPAM pool. Note the following:. - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR. - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored. Possible values: Any available IPv4 or IPv6 CIDR.
        :param description: A description for the allocation.
        :param netmask_length: The netmask length of the CIDR you would like to allocate from the IPAM pool. Note the following:. - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR. - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea7a8d7dc762f36c7c42acf390ff33a5d901404e11e9316d7df8d7c29c9e6af0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMAllocationProps(
            ipam_pool_id=ipam_pool_id,
            cidr=cidr,
            description=description,
            netmask_length=netmask_length,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3ba0f7e823a6d4a60a4cb169b078ea9c23b3c54c729c78632914b49c5f2a4751)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ad213757c25805fb10120b0939b5a219ff19cbe5f92a4728e9e1a0444c5c64dd)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamPoolAllocationId")
    def attr_ipam_pool_allocation_id(self) -> builtins.str:
        '''The ID of an allocation.

        :cloudformationAttribute: IpamPoolAllocationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamPoolAllocationId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="ipamPoolId")
    def ipam_pool_id(self) -> builtins.str:
        '''The ID of the IPAM pool from which you would like to allocate a CIDR.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamPoolId"))

    @ipam_pool_id.setter
    def ipam_pool_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__64e2f4cf4e3421886a498bb9e45ea019547a5f8e087690bbefc7fcea3586b903)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="cidr")
    def cidr(self) -> typing.Optional[builtins.str]:
        '''The CIDR you would like to allocate from the IPAM pool.

        Note the following:.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidr"))

    @cidr.setter
    def cidr(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b2e8a509e9710e3df3c5cdd45c6611dddda58579bcf820e4d97bf9783fc86238)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidr", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the allocation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae562f8439586f83a0987704d36755f7df5f4a7e5c8e2420a6f2a05dd208d415)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="netmaskLength")
    def netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the CIDR you would like to allocate from the IPAM pool.

        Note the following:.
        '''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "netmaskLength"))

    @netmask_length.setter
    def netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d9043b9cb409d41dda6d6f1b1ac81fccb06180f67f05749e5d26225f4844545)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "netmaskLength", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMAllocationProps",
    jsii_struct_bases=[],
    name_mapping={
        "ipam_pool_id": "ipamPoolId",
        "cidr": "cidr",
        "description": "description",
        "netmask_length": "netmaskLength",
    },
)
class CfnIPAMAllocationProps:
    def __init__(
        self,
        *,
        ipam_pool_id: builtins.str,
        cidr: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMAllocation``.

        :param ipam_pool_id: The ID of the IPAM pool from which you would like to allocate a CIDR.
        :param cidr: The CIDR you would like to allocate from the IPAM pool. Note the following:. - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR. - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored. Possible values: Any available IPv4 or IPv6 CIDR.
        :param description: A description for the allocation.
        :param netmask_length: The netmask length of the CIDR you would like to allocate from the IPAM pool. Note the following:. - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR. - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMAllocation_props = ec2.CfnIPAMAllocationProps(
                ipam_pool_id="ipamPoolId",
            
                # the properties below are optional
                cidr="cidr",
                description="description",
                netmask_length=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f074bee976b182b3e6932081b7e2343fe058af055ef039867eee673737cd6914)
            check_type(argname="argument ipam_pool_id", value=ipam_pool_id, expected_type=type_hints["ipam_pool_id"])
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument netmask_length", value=netmask_length, expected_type=type_hints["netmask_length"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipam_pool_id": ipam_pool_id,
        }
        if cidr is not None:
            self._values["cidr"] = cidr
        if description is not None:
            self._values["description"] = description
        if netmask_length is not None:
            self._values["netmask_length"] = netmask_length

    @builtins.property
    def ipam_pool_id(self) -> builtins.str:
        '''The ID of the IPAM pool from which you would like to allocate a CIDR.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html#cfn-ec2-ipamallocation-ipampoolid
        '''
        result = self._values.get("ipam_pool_id")
        assert result is not None, "Required property 'ipam_pool_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr(self) -> typing.Optional[builtins.str]:
        '''The CIDR you would like to allocate from the IPAM pool. Note the following:.

        - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR.
        - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored.

        Possible values: Any available IPv4 or IPv6 CIDR.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html#cfn-ec2-ipamallocation-cidr
        '''
        result = self._values.get("cidr")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the allocation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html#cfn-ec2-ipamallocation-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the CIDR you would like to allocate from the IPAM pool. Note the following:.

        - If there is no DefaultNetmaskLength allocation rule set on the pool, you must specify either the NetmaskLength or the CIDR.
        - If the DefaultNetmaskLength allocation rule is set on the pool, you can specify either the NetmaskLength or the CIDR and the DefaultNetmaskLength allocation rule will be ignored.

        Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamallocation.html#cfn-ec2-ipamallocation-netmasklength
        '''
        result = self._values.get("netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMAllocationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnIPAMPool(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPool",
):
    '''In IPAM, a pool is a collection of contiguous IP addresses CIDRs.

    Pools enable you to organize your IP addresses according to your routing and security needs. For example, if you have separate routing and security needs for development and production applications, you can create a pool for each.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html
    :cloudformationResource: AWS::EC2::IPAMPool
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMPool = ec2.CfnIPAMPool(self, "MyCfnIPAMPool",
            address_family="addressFamily",
            ipam_scope_id="ipamScopeId",
        
            # the properties below are optional
            allocation_default_netmask_length=123,
            allocation_max_netmask_length=123,
            allocation_min_netmask_length=123,
            allocation_resource_tags=[CfnTag(
                key="key",
                value="value"
            )],
            auto_import=False,
            aws_service="awsService",
            description="description",
            locale="locale",
            provisioned_cidrs=[ec2.CfnIPAMPool.ProvisionedCidrProperty(
                cidr="cidr"
            )],
            public_ip_source="publicIpSource",
            publicly_advertisable=False,
            source_ipam_pool_id="sourceIpamPoolId",
            source_resource=ec2.CfnIPAMPool.SourceResourceProperty(
                resource_id="resourceId",
                resource_owner="resourceOwner",
                resource_region="resourceRegion",
                resource_type="resourceType"
            ),
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        address_family: builtins.str,
        ipam_scope_id: builtins.str,
        allocation_default_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_max_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_min_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_resource_tags: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        auto_import: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        aws_service: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        locale: typing.Optional[builtins.str] = None,
        provisioned_cidrs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIPAMPool.ProvisionedCidrProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        public_ip_source: typing.Optional[builtins.str] = None,
        publicly_advertisable: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        source_ipam_pool_id: typing.Optional[builtins.str] = None,
        source_resource: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIPAMPool.SourceResourceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param address_family: The address family of the pool.
        :param ipam_scope_id: The ID of the scope in which you would like to create the IPAM pool.
        :param allocation_default_netmask_length: The default netmask length for allocations added to this pool. If, for example, the CIDR assigned to this pool is 10.0.0.0/8 and you enter 16 here, new allocations will default to 10.0.0.0/16.
        :param allocation_max_netmask_length: The maximum netmask length possible for CIDR allocations in this IPAM pool to be compliant. The maximum netmask length must be greater than the minimum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.
        :param allocation_min_netmask_length: The minimum netmask length required for CIDR allocations in this IPAM pool to be compliant. The minimum netmask length must be less than the maximum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.
        :param allocation_resource_tags: Tags that are required for resources that use CIDRs from this IPAM pool. Resources that do not have these tags will not be allowed to allocate space from the pool. If the resources have their tags changed after they have allocated space or if the allocation tagging requirements are changed on the pool, the resource may be marked as noncompliant.
        :param auto_import: If selected, IPAM will continuously look for resources within the CIDR range of this pool and automatically import them as allocations into your IPAM. The CIDRs that will be allocated for these resources must not already be allocated to other resources in order for the import to succeed. IPAM will import a CIDR regardless of its compliance with the pool's allocation rules, so a resource might be imported and subsequently marked as noncompliant. If IPAM discovers multiple CIDRs that overlap, IPAM will import the largest CIDR only. If IPAM discovers multiple CIDRs with matching CIDRs, IPAM will randomly import one of them only. A locale must be set on the pool for this feature to work.
        :param aws_service: Limits which service in AWS that the pool can be used in. "ec2", for example, allows users to use space for Elastic IP addresses and VPCs.
        :param description: The description of the IPAM pool.
        :param locale: The locale of the IPAM pool. In IPAM, the locale is the AWS Region where you want to make an IPAM pool available for allocations. Only resources in the same Region as the locale of the pool can get IP address allocations from the pool. You can only allocate a CIDR for a VPC, for example, from an IPAM pool that shares a locale with the VPC’s Region. Note that once you choose a Locale for a pool, you cannot modify it. If you choose an AWS Region for locale that has not been configured as an operating Region for the IPAM, you'll get an error.
        :param provisioned_cidrs: Information about the CIDRs provisioned to an IPAM pool.
        :param public_ip_source: The IP address source for pools in the public scope. Only used for provisioning IP address CIDRs to pools in the public scope. Default is ``BYOIP`` . For more information, see `Create IPv6 pools <https://docs.aws.amazon.com//vpc/latest/ipam/intro-create-ipv6-pools.html>`_ in the *Amazon VPC IPAM User Guide* . By default, you can add only one Amazon-provided IPv6 CIDR block to a top-level IPv6 pool. For information on increasing the default limit, see `Quotas for your IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/quotas-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param publicly_advertisable: Determines if a pool is publicly advertisable. This option is not available for pools with AddressFamily set to ``ipv4`` .
        :param source_ipam_pool_id: The ID of the source IPAM pool. You can use this option to create an IPAM pool within an existing source pool.
        :param source_resource: The resource used to provision CIDRs to a resource planning pool.
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49ac69dacc9e55c18363e598ee436fae30723dd4b487a4cd51477854696d9739)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMPoolProps(
            address_family=address_family,
            ipam_scope_id=ipam_scope_id,
            allocation_default_netmask_length=allocation_default_netmask_length,
            allocation_max_netmask_length=allocation_max_netmask_length,
            allocation_min_netmask_length=allocation_min_netmask_length,
            allocation_resource_tags=allocation_resource_tags,
            auto_import=auto_import,
            aws_service=aws_service,
            description=description,
            locale=locale,
            provisioned_cidrs=provisioned_cidrs,
            public_ip_source=public_ip_source,
            publicly_advertisable=publicly_advertisable,
            source_ipam_pool_id=source_ipam_pool_id,
            source_resource=source_resource,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed624bf3dc307f04a3b45acad98bea6483b1a66eab0f2a9472fa9843d91564b2)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e7676e43df5cfe9b5768db72cf66c10335a772ff51e6a339deb5179a8979067)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrArn")
    def attr_arn(self) -> builtins.str:
        '''The ARN of the IPAM pool.

        :cloudformationAttribute: Arn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamArn")
    def attr_ipam_arn(self) -> builtins.str:
        '''The ARN of the IPAM.

        :cloudformationAttribute: IpamArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamPoolId")
    def attr_ipam_pool_id(self) -> builtins.str:
        '''The ID of the IPAM pool.

        :cloudformationAttribute: IpamPoolId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamPoolId"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamScopeArn")
    def attr_ipam_scope_arn(self) -> builtins.str:
        '''The ARN of the scope of the IPAM pool.

        :cloudformationAttribute: IpamScopeArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamScopeArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamScopeType")
    def attr_ipam_scope_type(self) -> builtins.str:
        '''The scope of the IPAM.

        :cloudformationAttribute: IpamScopeType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamScopeType"))

    @builtins.property
    @jsii.member(jsii_name="attrPoolDepth")
    def attr_pool_depth(self) -> jsii.Number:
        '''The depth of pools in your IPAM pool.

        The pool depth quota is 10.

        :cloudformationAttribute: PoolDepth
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrPoolDepth"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the IPAM pool.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="attrStateMessage")
    def attr_state_message(self) -> builtins.str:
        '''A message related to the failed creation of an IPAM pool.

        :cloudformationAttribute: StateMessage
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStateMessage"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="addressFamily")
    def address_family(self) -> builtins.str:
        '''The address family of the pool.'''
        return typing.cast(builtins.str, jsii.get(self, "addressFamily"))

    @address_family.setter
    def address_family(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a5b241c251a5a66afb68207fac43059c8a2515b97d3b1cc207e2657902e71b1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "addressFamily", value)

    @builtins.property
    @jsii.member(jsii_name="ipamScopeId")
    def ipam_scope_id(self) -> builtins.str:
        '''The ID of the scope in which you would like to create the IPAM pool.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamScopeId"))

    @ipam_scope_id.setter
    def ipam_scope_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3fbdbec1bdf539bf7935f66283de5d2455b37fd036bd5f6e2f5ad52c42338fb1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamScopeId", value)

    @builtins.property
    @jsii.member(jsii_name="allocationDefaultNetmaskLength")
    def allocation_default_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The default netmask length for allocations added to this pool.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "allocationDefaultNetmaskLength"))

    @allocation_default_netmask_length.setter
    def allocation_default_netmask_length(
        self,
        value: typing.Optional[jsii.Number],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb67e5df586c19b16abaf86994738112eed024ce90016e4c18b7dd264553f702)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationDefaultNetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="allocationMaxNetmaskLength")
    def allocation_max_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The maximum netmask length possible for CIDR allocations in this IPAM pool to be compliant.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "allocationMaxNetmaskLength"))

    @allocation_max_netmask_length.setter
    def allocation_max_netmask_length(
        self,
        value: typing.Optional[jsii.Number],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ff43fa5869f5613ca15882015827b8534dcb8488bc50fe83a2d7974080f5420)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationMaxNetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="allocationMinNetmaskLength")
    def allocation_min_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The minimum netmask length required for CIDR allocations in this IPAM pool to be compliant.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "allocationMinNetmaskLength"))

    @allocation_min_netmask_length.setter
    def allocation_min_netmask_length(
        self,
        value: typing.Optional[jsii.Number],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__841766c7de2c1b457f6e90e16e2c5de9d9ad55f57131bf4ebe7e22c651a5871a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationMinNetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="allocationResourceTags")
    def allocation_resource_tags(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]]:
        '''Tags that are required for resources that use CIDRs from this IPAM pool.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]], jsii.get(self, "allocationResourceTags"))

    @allocation_resource_tags.setter
    def allocation_resource_tags(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00c43e28a217efdf34866f8f436e0d615b3f76ef33d75a0fcd54107f4fcd2395)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationResourceTags", value)

    @builtins.property
    @jsii.member(jsii_name="autoImport")
    def auto_import(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''If selected, IPAM will continuously look for resources within the CIDR range of this pool and automatically import them as allocations into your IPAM.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "autoImport"))

    @auto_import.setter
    def auto_import(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3bef013417f7aecffe6df419f044a34ba6c1056e4c6fe41fab3f61c1c98629e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "autoImport", value)

    @builtins.property
    @jsii.member(jsii_name="awsService")
    def aws_service(self) -> typing.Optional[builtins.str]:
        '''Limits which service in AWS that the pool can be used in.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "awsService"))

    @aws_service.setter
    def aws_service(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3e466f53a7750a1bd0f9875419a5a1b56600ca1c8fc7f153ecaab870fc5b5876)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "awsService", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the IPAM pool.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bcec51b995a93f9fe674b9eb0c8ec907bb474c040116a93fcfe16794efc35e8b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="locale")
    def locale(self) -> typing.Optional[builtins.str]:
        '''The locale of the IPAM pool.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "locale"))

    @locale.setter
    def locale(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f634bcf807180517176b75391374db468661710cf7172f3ee46b626259a33de)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "locale", value)

    @builtins.property
    @jsii.member(jsii_name="provisionedCidrs")
    def provisioned_cidrs(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.ProvisionedCidrProperty"]]]]:
        '''Information about the CIDRs provisioned to an IPAM pool.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.ProvisionedCidrProperty"]]]], jsii.get(self, "provisionedCidrs"))

    @provisioned_cidrs.setter
    def provisioned_cidrs(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.ProvisionedCidrProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2ec724b5a099431c168859f8bae8690b6942bf2c4428928ba37a452bf8eab6a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "provisionedCidrs", value)

    @builtins.property
    @jsii.member(jsii_name="publicIpSource")
    def public_ip_source(self) -> typing.Optional[builtins.str]:
        '''The IP address source for pools in the public scope.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "publicIpSource"))

    @public_ip_source.setter
    def public_ip_source(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67c2537c8cc935adffb5c8b6b1f780d4d25f1c3bcead923fd22423ccb9eff737)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "publicIpSource", value)

    @builtins.property
    @jsii.member(jsii_name="publiclyAdvertisable")
    def publicly_advertisable(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Determines if a pool is publicly advertisable.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "publiclyAdvertisable"))

    @publicly_advertisable.setter
    def publicly_advertisable(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a2c1d055ef4dd3ab27084865a5b4dc034dc0c587c1cfc2aef7e63cafc581793c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "publiclyAdvertisable", value)

    @builtins.property
    @jsii.member(jsii_name="sourceIpamPoolId")
    def source_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the source IPAM pool.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourceIpamPoolId"))

    @source_ipam_pool_id.setter
    def source_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__324d3ea5d3ecf303ca16390cb4f68ab2b30fc3cd3cf7c82ba59c99a16243a68b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceIpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="sourceResource")
    def source_resource(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.SourceResourceProperty"]]:
        '''The resource used to provision CIDRs to a resource planning pool.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.SourceResourceProperty"]], jsii.get(self, "sourceResource"))

    @source_resource.setter
    def source_resource(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnIPAMPool.SourceResourceProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3f70db41696848da5f2c3703ae0a09b95494dc9b1ba1e9e1147650712c765d52)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceResource", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5a27f882c280937fa0881f1d5fdc26d072d6a34ae1cdbaec63936d887ba4555)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPool.ProvisionedCidrProperty",
        jsii_struct_bases=[],
        name_mapping={"cidr": "cidr"},
    )
    class ProvisionedCidrProperty:
        def __init__(self, *, cidr: builtins.str) -> None:
            '''The CIDR provisioned to the IPAM pool.

            A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .
            .. epigraph::

               This resource type does not allow you to provision a CIDR using the netmask length. To provision a CIDR using netmask length, use `AWS::EC2::IPAMPoolCidr <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html>`_ .

            :param cidr: The CIDR provisioned to the IPAM pool. A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-provisionedcidr.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                provisioned_cidr_property = ec2.CfnIPAMPool.ProvisionedCidrProperty(
                    cidr="cidr"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__fff1e35b565a960234fe5a7c634cdd72887d66cc483af55f294c6fc9ca10476d)
                check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "cidr": cidr,
            }

        @builtins.property
        def cidr(self) -> builtins.str:
            '''The CIDR provisioned to the IPAM pool.

            A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-provisionedcidr.html#cfn-ec2-ipampool-provisionedcidr-cidr
            '''
            result = self._values.get("cidr")
            assert result is not None, "Required property 'cidr' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ProvisionedCidrProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPool.SourceResourceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "resource_id": "resourceId",
            "resource_owner": "resourceOwner",
            "resource_region": "resourceRegion",
            "resource_type": "resourceType",
        },
    )
    class SourceResourceProperty:
        def __init__(
            self,
            *,
            resource_id: builtins.str,
            resource_owner: builtins.str,
            resource_region: builtins.str,
            resource_type: builtins.str,
        ) -> None:
            '''The resource used to provision CIDRs to a resource planning pool.

            :param resource_id: The source resource ID.
            :param resource_owner: The source resource owner.
            :param resource_region: The source resource Region.
            :param resource_type: The source resource type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-sourceresource.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                source_resource_property = ec2.CfnIPAMPool.SourceResourceProperty(
                    resource_id="resourceId",
                    resource_owner="resourceOwner",
                    resource_region="resourceRegion",
                    resource_type="resourceType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__499a6dc3aca0b20e81b7aa4c45945c37a69bc00be56b64d258b95bd99e3d3db8)
                check_type(argname="argument resource_id", value=resource_id, expected_type=type_hints["resource_id"])
                check_type(argname="argument resource_owner", value=resource_owner, expected_type=type_hints["resource_owner"])
                check_type(argname="argument resource_region", value=resource_region, expected_type=type_hints["resource_region"])
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "resource_id": resource_id,
                "resource_owner": resource_owner,
                "resource_region": resource_region,
                "resource_type": resource_type,
            }

        @builtins.property
        def resource_id(self) -> builtins.str:
            '''The source resource ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-sourceresource.html#cfn-ec2-ipampool-sourceresource-resourceid
            '''
            result = self._values.get("resource_id")
            assert result is not None, "Required property 'resource_id' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def resource_owner(self) -> builtins.str:
            '''The source resource owner.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-sourceresource.html#cfn-ec2-ipampool-sourceresource-resourceowner
            '''
            result = self._values.get("resource_owner")
            assert result is not None, "Required property 'resource_owner' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def resource_region(self) -> builtins.str:
            '''The source resource Region.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-sourceresource.html#cfn-ec2-ipampool-sourceresource-resourceregion
            '''
            result = self._values.get("resource_region")
            assert result is not None, "Required property 'resource_region' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def resource_type(self) -> builtins.str:
            '''The source resource type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipampool-sourceresource.html#cfn-ec2-ipampool-sourceresource-resourcetype
            '''
            result = self._values.get("resource_type")
            assert result is not None, "Required property 'resource_type' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SourceResourceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnIPAMPoolCidr(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPoolCidr",
):
    '''A CIDR provisioned to an IPAM pool.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html
    :cloudformationResource: AWS::EC2::IPAMPoolCidr
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMPool_cidr = ec2.CfnIPAMPoolCidr(self, "MyCfnIPAMPoolCidr",
            ipam_pool_id="ipamPoolId",
        
            # the properties below are optional
            cidr="cidr",
            netmask_length=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ipam_pool_id: builtins.str,
        cidr: typing.Optional[builtins.str] = None,
        netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param ipam_pool_id: The ID of the IPAM pool.
        :param cidr: The CIDR provisioned to the IPAM pool. A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .
        :param netmask_length: The netmask length of the CIDR you'd like to provision to a pool. Can be used for provisioning Amazon-provided IPv6 CIDRs to top-level pools and for provisioning CIDRs to pools with source pools. Cannot be used to provision BYOIP CIDRs to top-level pools. "NetmaskLength" or "Cidr" is required.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8784d64f2ed9d5c5895a39ee2f303c65f7cbf35f09f8eb6a6e590f7adcf217be)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMPoolCidrProps(
            ipam_pool_id=ipam_pool_id, cidr=cidr, netmask_length=netmask_length
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67f4fbe564d6d7617267d90115cf76c866b19ef78aac34898ab34a9b389d9f70)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0e5bee11f6dc0a79c374293f45edd7e710b263b2f05a59e64a11d3fe5e48cc69)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamPoolCidrId")
    def attr_ipam_pool_cidr_id(self) -> builtins.str:
        '''The IPAM pool CIDR ID.

        :cloudformationAttribute: IpamPoolCidrId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamPoolCidrId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the CIDR.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="ipamPoolId")
    def ipam_pool_id(self) -> builtins.str:
        '''The ID of the IPAM pool.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamPoolId"))

    @ipam_pool_id.setter
    def ipam_pool_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__604012fe0368b158338f3d6974a78e5e58e5c236b6ab4115d040a7eb4ecc1ce0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="cidr")
    def cidr(self) -> typing.Optional[builtins.str]:
        '''The CIDR provisioned to the IPAM pool.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidr"))

    @cidr.setter
    def cidr(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf90b94d3e69aac519821a92155ed9c530ab8f3c04676ea35a1bce7b5e4d5674)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidr", value)

    @builtins.property
    @jsii.member(jsii_name="netmaskLength")
    def netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the CIDR you'd like to provision to a pool.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "netmaskLength"))

    @netmask_length.setter
    def netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32ded8ef5c4803ee43c7716ccda0fe7c6c3490433df2a1a6d618465414541ad1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "netmaskLength", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPoolCidrProps",
    jsii_struct_bases=[],
    name_mapping={
        "ipam_pool_id": "ipamPoolId",
        "cidr": "cidr",
        "netmask_length": "netmaskLength",
    },
)
class CfnIPAMPoolCidrProps:
    def __init__(
        self,
        *,
        ipam_pool_id: builtins.str,
        cidr: typing.Optional[builtins.str] = None,
        netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMPoolCidr``.

        :param ipam_pool_id: The ID of the IPAM pool.
        :param cidr: The CIDR provisioned to the IPAM pool. A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .
        :param netmask_length: The netmask length of the CIDR you'd like to provision to a pool. Can be used for provisioning Amazon-provided IPv6 CIDRs to top-level pools and for provisioning CIDRs to pools with source pools. Cannot be used to provision BYOIP CIDRs to top-level pools. "NetmaskLength" or "Cidr" is required.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMPool_cidr_props = ec2.CfnIPAMPoolCidrProps(
                ipam_pool_id="ipamPoolId",
            
                # the properties below are optional
                cidr="cidr",
                netmask_length=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdded95565386b2554341a7bf1237ba2394f4be9ae7bba368c7bfe4909dc0f09)
            check_type(argname="argument ipam_pool_id", value=ipam_pool_id, expected_type=type_hints["ipam_pool_id"])
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument netmask_length", value=netmask_length, expected_type=type_hints["netmask_length"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipam_pool_id": ipam_pool_id,
        }
        if cidr is not None:
            self._values["cidr"] = cidr
        if netmask_length is not None:
            self._values["netmask_length"] = netmask_length

    @builtins.property
    def ipam_pool_id(self) -> builtins.str:
        '''The ID of the IPAM pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html#cfn-ec2-ipampoolcidr-ipampoolid
        '''
        result = self._values.get("ipam_pool_id")
        assert result is not None, "Required property 'ipam_pool_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr(self) -> typing.Optional[builtins.str]:
        '''The CIDR provisioned to the IPAM pool.

        A CIDR is a representation of an IP address and its associated network mask (or netmask) and refers to a range of IP addresses. An IPv4 CIDR example is ``10.24.34.0/23`` . An IPv6 CIDR example is ``2001:DB8::/32`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html#cfn-ec2-ipampoolcidr-cidr
        '''
        result = self._values.get("cidr")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the CIDR you'd like to provision to a pool.

        Can be used for provisioning Amazon-provided IPv6 CIDRs to top-level pools and for provisioning CIDRs to pools with source pools. Cannot be used to provision BYOIP CIDRs to top-level pools. "NetmaskLength" or "Cidr" is required.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html#cfn-ec2-ipampoolcidr-netmasklength
        '''
        result = self._values.get("netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMPoolCidrProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMPoolProps",
    jsii_struct_bases=[],
    name_mapping={
        "address_family": "addressFamily",
        "ipam_scope_id": "ipamScopeId",
        "allocation_default_netmask_length": "allocationDefaultNetmaskLength",
        "allocation_max_netmask_length": "allocationMaxNetmaskLength",
        "allocation_min_netmask_length": "allocationMinNetmaskLength",
        "allocation_resource_tags": "allocationResourceTags",
        "auto_import": "autoImport",
        "aws_service": "awsService",
        "description": "description",
        "locale": "locale",
        "provisioned_cidrs": "provisionedCidrs",
        "public_ip_source": "publicIpSource",
        "publicly_advertisable": "publiclyAdvertisable",
        "source_ipam_pool_id": "sourceIpamPoolId",
        "source_resource": "sourceResource",
        "tags": "tags",
    },
)
class CfnIPAMPoolProps:
    def __init__(
        self,
        *,
        address_family: builtins.str,
        ipam_scope_id: builtins.str,
        allocation_default_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_max_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_min_netmask_length: typing.Optional[jsii.Number] = None,
        allocation_resource_tags: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        auto_import: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        aws_service: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        locale: typing.Optional[builtins.str] = None,
        provisioned_cidrs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.ProvisionedCidrProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        public_ip_source: typing.Optional[builtins.str] = None,
        publicly_advertisable: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        source_ipam_pool_id: typing.Optional[builtins.str] = None,
        source_resource: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.SourceResourceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMPool``.

        :param address_family: The address family of the pool.
        :param ipam_scope_id: The ID of the scope in which you would like to create the IPAM pool.
        :param allocation_default_netmask_length: The default netmask length for allocations added to this pool. If, for example, the CIDR assigned to this pool is 10.0.0.0/8 and you enter 16 here, new allocations will default to 10.0.0.0/16.
        :param allocation_max_netmask_length: The maximum netmask length possible for CIDR allocations in this IPAM pool to be compliant. The maximum netmask length must be greater than the minimum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.
        :param allocation_min_netmask_length: The minimum netmask length required for CIDR allocations in this IPAM pool to be compliant. The minimum netmask length must be less than the maximum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.
        :param allocation_resource_tags: Tags that are required for resources that use CIDRs from this IPAM pool. Resources that do not have these tags will not be allowed to allocate space from the pool. If the resources have their tags changed after they have allocated space or if the allocation tagging requirements are changed on the pool, the resource may be marked as noncompliant.
        :param auto_import: If selected, IPAM will continuously look for resources within the CIDR range of this pool and automatically import them as allocations into your IPAM. The CIDRs that will be allocated for these resources must not already be allocated to other resources in order for the import to succeed. IPAM will import a CIDR regardless of its compliance with the pool's allocation rules, so a resource might be imported and subsequently marked as noncompliant. If IPAM discovers multiple CIDRs that overlap, IPAM will import the largest CIDR only. If IPAM discovers multiple CIDRs with matching CIDRs, IPAM will randomly import one of them only. A locale must be set on the pool for this feature to work.
        :param aws_service: Limits which service in AWS that the pool can be used in. "ec2", for example, allows users to use space for Elastic IP addresses and VPCs.
        :param description: The description of the IPAM pool.
        :param locale: The locale of the IPAM pool. In IPAM, the locale is the AWS Region where you want to make an IPAM pool available for allocations. Only resources in the same Region as the locale of the pool can get IP address allocations from the pool. You can only allocate a CIDR for a VPC, for example, from an IPAM pool that shares a locale with the VPC’s Region. Note that once you choose a Locale for a pool, you cannot modify it. If you choose an AWS Region for locale that has not been configured as an operating Region for the IPAM, you'll get an error.
        :param provisioned_cidrs: Information about the CIDRs provisioned to an IPAM pool.
        :param public_ip_source: The IP address source for pools in the public scope. Only used for provisioning IP address CIDRs to pools in the public scope. Default is ``BYOIP`` . For more information, see `Create IPv6 pools <https://docs.aws.amazon.com//vpc/latest/ipam/intro-create-ipv6-pools.html>`_ in the *Amazon VPC IPAM User Guide* . By default, you can add only one Amazon-provided IPv6 CIDR block to a top-level IPv6 pool. For information on increasing the default limit, see `Quotas for your IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/quotas-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param publicly_advertisable: Determines if a pool is publicly advertisable. This option is not available for pools with AddressFamily set to ``ipv4`` .
        :param source_ipam_pool_id: The ID of the source IPAM pool. You can use this option to create an IPAM pool within an existing source pool.
        :param source_resource: The resource used to provision CIDRs to a resource planning pool.
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMPool_props = ec2.CfnIPAMPoolProps(
                address_family="addressFamily",
                ipam_scope_id="ipamScopeId",
            
                # the properties below are optional
                allocation_default_netmask_length=123,
                allocation_max_netmask_length=123,
                allocation_min_netmask_length=123,
                allocation_resource_tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                auto_import=False,
                aws_service="awsService",
                description="description",
                locale="locale",
                provisioned_cidrs=[ec2.CfnIPAMPool.ProvisionedCidrProperty(
                    cidr="cidr"
                )],
                public_ip_source="publicIpSource",
                publicly_advertisable=False,
                source_ipam_pool_id="sourceIpamPoolId",
                source_resource=ec2.CfnIPAMPool.SourceResourceProperty(
                    resource_id="resourceId",
                    resource_owner="resourceOwner",
                    resource_region="resourceRegion",
                    resource_type="resourceType"
                ),
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c42f207097d7881d4b52878ebd2ec0ae90f2bf68e18d515c40977733d8d9b124)
            check_type(argname="argument address_family", value=address_family, expected_type=type_hints["address_family"])
            check_type(argname="argument ipam_scope_id", value=ipam_scope_id, expected_type=type_hints["ipam_scope_id"])
            check_type(argname="argument allocation_default_netmask_length", value=allocation_default_netmask_length, expected_type=type_hints["allocation_default_netmask_length"])
            check_type(argname="argument allocation_max_netmask_length", value=allocation_max_netmask_length, expected_type=type_hints["allocation_max_netmask_length"])
            check_type(argname="argument allocation_min_netmask_length", value=allocation_min_netmask_length, expected_type=type_hints["allocation_min_netmask_length"])
            check_type(argname="argument allocation_resource_tags", value=allocation_resource_tags, expected_type=type_hints["allocation_resource_tags"])
            check_type(argname="argument auto_import", value=auto_import, expected_type=type_hints["auto_import"])
            check_type(argname="argument aws_service", value=aws_service, expected_type=type_hints["aws_service"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument locale", value=locale, expected_type=type_hints["locale"])
            check_type(argname="argument provisioned_cidrs", value=provisioned_cidrs, expected_type=type_hints["provisioned_cidrs"])
            check_type(argname="argument public_ip_source", value=public_ip_source, expected_type=type_hints["public_ip_source"])
            check_type(argname="argument publicly_advertisable", value=publicly_advertisable, expected_type=type_hints["publicly_advertisable"])
            check_type(argname="argument source_ipam_pool_id", value=source_ipam_pool_id, expected_type=type_hints["source_ipam_pool_id"])
            check_type(argname="argument source_resource", value=source_resource, expected_type=type_hints["source_resource"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "address_family": address_family,
            "ipam_scope_id": ipam_scope_id,
        }
        if allocation_default_netmask_length is not None:
            self._values["allocation_default_netmask_length"] = allocation_default_netmask_length
        if allocation_max_netmask_length is not None:
            self._values["allocation_max_netmask_length"] = allocation_max_netmask_length
        if allocation_min_netmask_length is not None:
            self._values["allocation_min_netmask_length"] = allocation_min_netmask_length
        if allocation_resource_tags is not None:
            self._values["allocation_resource_tags"] = allocation_resource_tags
        if auto_import is not None:
            self._values["auto_import"] = auto_import
        if aws_service is not None:
            self._values["aws_service"] = aws_service
        if description is not None:
            self._values["description"] = description
        if locale is not None:
            self._values["locale"] = locale
        if provisioned_cidrs is not None:
            self._values["provisioned_cidrs"] = provisioned_cidrs
        if public_ip_source is not None:
            self._values["public_ip_source"] = public_ip_source
        if publicly_advertisable is not None:
            self._values["publicly_advertisable"] = publicly_advertisable
        if source_ipam_pool_id is not None:
            self._values["source_ipam_pool_id"] = source_ipam_pool_id
        if source_resource is not None:
            self._values["source_resource"] = source_resource
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def address_family(self) -> builtins.str:
        '''The address family of the pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-addressfamily
        '''
        result = self._values.get("address_family")
        assert result is not None, "Required property 'address_family' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ipam_scope_id(self) -> builtins.str:
        '''The ID of the scope in which you would like to create the IPAM pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-ipamscopeid
        '''
        result = self._values.get("ipam_scope_id")
        assert result is not None, "Required property 'ipam_scope_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def allocation_default_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The default netmask length for allocations added to this pool.

        If, for example, the CIDR assigned to this pool is 10.0.0.0/8 and you enter 16 here, new allocations will default to 10.0.0.0/16.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-allocationdefaultnetmasklength
        '''
        result = self._values.get("allocation_default_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def allocation_max_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The maximum netmask length possible for CIDR allocations in this IPAM pool to be compliant.

        The maximum netmask length must be greater than the minimum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-allocationmaxnetmasklength
        '''
        result = self._values.get("allocation_max_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def allocation_min_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The minimum netmask length required for CIDR allocations in this IPAM pool to be compliant.

        The minimum netmask length must be less than the maximum netmask length. Possible netmask lengths for IPv4 addresses are 0 - 32. Possible netmask lengths for IPv6 addresses are 0 - 128.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-allocationminnetmasklength
        '''
        result = self._values.get("allocation_min_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def allocation_resource_tags(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]]:
        '''Tags that are required for resources that use CIDRs from this IPAM pool.

        Resources that do not have these tags will not be allowed to allocate space from the pool. If the resources have their tags changed after they have allocated space or if the allocation tagging requirements are changed on the pool, the resource may be marked as noncompliant.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-allocationresourcetags
        '''
        result = self._values.get("allocation_resource_tags")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]], result)

    @builtins.property
    def auto_import(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''If selected, IPAM will continuously look for resources within the CIDR range of this pool and automatically import them as allocations into your IPAM.

        The CIDRs that will be allocated for these resources must not already be allocated to other resources in order for the import to succeed. IPAM will import a CIDR regardless of its compliance with the pool's allocation rules, so a resource might be imported and subsequently marked as noncompliant. If IPAM discovers multiple CIDRs that overlap, IPAM will import the largest CIDR only. If IPAM discovers multiple CIDRs with matching CIDRs, IPAM will randomly import one of them only.

        A locale must be set on the pool for this feature to work.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-autoimport
        '''
        result = self._values.get("auto_import")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def aws_service(self) -> typing.Optional[builtins.str]:
        '''Limits which service in AWS that the pool can be used in.

        "ec2", for example, allows users to use space for Elastic IP addresses and VPCs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-awsservice
        '''
        result = self._values.get("aws_service")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the IPAM pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def locale(self) -> typing.Optional[builtins.str]:
        '''The locale of the IPAM pool.

        In IPAM, the locale is the AWS Region where you want to make an IPAM pool available for allocations. Only resources in the same Region as the locale of the pool can get IP address allocations from the pool. You can only allocate a CIDR for a VPC, for example, from an IPAM pool that shares a locale with the VPC’s Region. Note that once you choose a Locale for a pool, you cannot modify it. If you choose an AWS Region for locale that has not been configured as an operating Region for the IPAM, you'll get an error.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-locale
        '''
        result = self._values.get("locale")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def provisioned_cidrs(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.ProvisionedCidrProperty]]]]:
        '''Information about the CIDRs provisioned to an IPAM pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-provisionedcidrs
        '''
        result = self._values.get("provisioned_cidrs")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.ProvisionedCidrProperty]]]], result)

    @builtins.property
    def public_ip_source(self) -> typing.Optional[builtins.str]:
        '''The IP address source for pools in the public scope.

        Only used for provisioning IP address CIDRs to pools in the public scope. Default is ``BYOIP`` . For more information, see `Create IPv6 pools <https://docs.aws.amazon.com//vpc/latest/ipam/intro-create-ipv6-pools.html>`_ in the *Amazon VPC IPAM User Guide* . By default, you can add only one Amazon-provided IPv6 CIDR block to a top-level IPv6 pool. For information on increasing the default limit, see `Quotas for your IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/quotas-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-publicipsource
        '''
        result = self._values.get("public_ip_source")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def publicly_advertisable(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Determines if a pool is publicly advertisable.

        This option is not available for pools with AddressFamily set to ``ipv4`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-publiclyadvertisable
        '''
        result = self._values.get("publicly_advertisable")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def source_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the source IPAM pool.

        You can use this option to create an IPAM pool within an existing source pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-sourceipampoolid
        '''
        result = self._values.get("source_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_resource(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.SourceResourceProperty]]:
        '''The resource used to provision CIDRs to a resource planning pool.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-sourceresource
        '''
        result = self._values.get("source_resource")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.SourceResourceProperty]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.

        Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMPoolProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "operating_regions": "operatingRegions",
        "tags": "tags",
        "tier": "tier",
    },
)
class CfnIPAMProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAM.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        tier: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAM``.

        :param description: The description for the IPAM.
        :param operating_regions: The operating Regions for an IPAM. Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions. For more information about operating Regions, see `Create an IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.
        :param tier: IPAM is offered in a Free Tier and an Advanced Tier. For more information about the features available in each tier and the costs associated with the tiers, see the `VPC IPAM product pricing page <https://docs.aws.amazon.com//vpc/pricing/>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMProps = ec2.CfnIPAMProps(
                description="description",
                operating_regions=[ec2.CfnIPAM.IpamOperatingRegionProperty(
                    region_name="regionName"
                )],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                tier="tier"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1252b3f41198f9c0d9b0c751334626e1084e0106d3be9d92d77200730b95e90)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument operating_regions", value=operating_regions, expected_type=type_hints["operating_regions"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument tier", value=tier, expected_type=type_hints["tier"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if operating_regions is not None:
            self._values["operating_regions"] = operating_regions
        if tags is not None:
            self._values["tags"] = tags
        if tier is not None:
            self._values["tier"] = tier

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description for the IPAM.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def operating_regions(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAM.IpamOperatingRegionProperty]]]]:
        '''The operating Regions for an IPAM.

        Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.

        For more information about operating Regions, see `Create an IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-operatingregions
        '''
        result = self._values.get("operating_regions")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAM.IpamOperatingRegionProperty]]]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.

        Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def tier(self) -> typing.Optional[builtins.str]:
        '''IPAM is offered in a Free Tier and an Advanced Tier.

        For more information about the features available in each tier and the costs associated with the tiers, see the `VPC IPAM product pricing page <https://docs.aws.amazon.com//vpc/pricing/>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-tier
        '''
        result = self._values.get("tier")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnIPAMResourceDiscovery(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMResourceDiscovery",
):
    '''A resource discovery is an IPAM component that enables IPAM to manage and monitor resources that belong to the owning account.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscovery.html
    :cloudformationResource: AWS::EC2::IPAMResourceDiscovery
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMResource_discovery = ec2.CfnIPAMResourceDiscovery(self, "MyCfnIPAMResourceDiscovery",
            description="description",
            operating_regions=[ec2.CfnIPAMResourceDiscovery.IpamOperatingRegionProperty(
                region_name="regionName"
            )],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnIPAMResourceDiscovery.IpamOperatingRegionProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param description: The resource discovery description.
        :param operating_regions: The operating Regions for the resource discovery. Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.
        :param tags: A tag is a label that you assign to an AWS resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b9865e76fdfd7caecfedb4df232a297c92dc11c534785272c111c4d0ba492cfd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMResourceDiscoveryProps(
            description=description, operating_regions=operating_regions, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1d8c82f3dfe9b8619160b061cf8b66f8028c4b53cd00fc8313e6ceec44d1e6b)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c37f9297c88eb6473630fb8466d9077db4b53894926c42cdba143b510e3e6711)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamResourceDiscoveryArn")
    def attr_ipam_resource_discovery_arn(self) -> builtins.str:
        '''The resource discovery ARN.

        :cloudformationAttribute: IpamResourceDiscoveryArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamResourceDiscoveryArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamResourceDiscoveryId")
    def attr_ipam_resource_discovery_id(self) -> builtins.str:
        '''The resource discovery ID.

        :cloudformationAttribute: IpamResourceDiscoveryId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamResourceDiscoveryId"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamResourceDiscoveryRegion")
    def attr_ipam_resource_discovery_region(self) -> builtins.str:
        '''The resource discovery Region.

        :cloudformationAttribute: IpamResourceDiscoveryRegion
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamResourceDiscoveryRegion"))

    @builtins.property
    @jsii.member(jsii_name="attrIsDefault")
    def attr_is_default(self) -> _IResolvable_da3f097b:
        '''Defines if the resource discovery is the default.

        The default resource discovery is the resource discovery automatically created when you create an IPAM.

        :cloudformationAttribute: IsDefault
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrIsDefault"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The owner ID.

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The resource discovery's state.

        - ``create-in-progress`` - Resource discovery is being created.
        - ``create-complete`` - Resource discovery creation is complete.
        - ``create-failed`` - Resource discovery creation has failed.
        - ``modify-in-progress`` - Resource discovery is being modified.
        - ``modify-complete`` - Resource discovery modification is complete.
        - ``modify-failed`` - Resource discovery modification has failed.
        - ``delete-in-progress`` - Resource discovery is being deleted.
        - ``delete-complete`` - Resource discovery deletion is complete.
        - ``delete-failed`` - Resource discovery deletion has failed.
        - ``isolate-in-progress`` - AWS account that created the resource discovery has been removed and the resource discovery is being isolated.
        - ``isolate-complete`` - Resource discovery isolation is complete.
        - ``restore-in-progress`` - AWS account that created the resource discovery and was isolated has been restored.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The resource discovery description.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__639c336864ab565a700853f71e9677e8bfaa918f3f432f4b43f243b7579647b2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="operatingRegions")
    def operating_regions(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMResourceDiscovery.IpamOperatingRegionProperty"]]]]:
        '''The operating Regions for the resource discovery.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMResourceDiscovery.IpamOperatingRegionProperty"]]]], jsii.get(self, "operatingRegions"))

    @operating_regions.setter
    def operating_regions(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnIPAMResourceDiscovery.IpamOperatingRegionProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08b5ef93b946df5cb347a5d9e125f158c9a540a9ac51f8d045f6c39510e73a00)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "operatingRegions", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''A tag is a label that you assign to an AWS resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e5af2028bd620ac6af11e15ae308dbbee822aa725e6ce8b9b68acafc97810a0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMResourceDiscovery.IpamOperatingRegionProperty",
        jsii_struct_bases=[],
        name_mapping={"region_name": "regionName"},
    )
    class IpamOperatingRegionProperty:
        def __init__(self, *, region_name: builtins.str) -> None:
            '''The operating Regions for an IPAM.

            Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.

            For more information about operating Regions, see `Create an IPAM <https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

            :param region_name: The name of the operating Region.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipamresourcediscovery-ipamoperatingregion.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipam_operating_region_property = ec2.CfnIPAMResourceDiscovery.IpamOperatingRegionProperty(
                    region_name="regionName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__fffd1bd7ad0ffb1481907684f9ea6caa474483fe9be95e99ef7b5bd42d761e4e)
                check_type(argname="argument region_name", value=region_name, expected_type=type_hints["region_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "region_name": region_name,
            }

        @builtins.property
        def region_name(self) -> builtins.str:
            '''The name of the operating Region.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ipamresourcediscovery-ipamoperatingregion.html#cfn-ec2-ipamresourcediscovery-ipamoperatingregion-regionname
            '''
            result = self._values.get("region_name")
            assert result is not None, "Required property 'region_name' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IpamOperatingRegionProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnIPAMResourceDiscoveryAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMResourceDiscoveryAssociation",
):
    '''An IPAM resource discovery association.

    An associated resource discovery is a resource discovery that has been associated with an IPAM. IPAM aggregates the resource CIDRs discovered by the associated resource discovery.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscoveryassociation.html
    :cloudformationResource: AWS::EC2::IPAMResourceDiscoveryAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMResource_discovery_association = ec2.CfnIPAMResourceDiscoveryAssociation(self, "MyCfnIPAMResourceDiscoveryAssociation",
            ipam_id="ipamId",
            ipam_resource_discovery_id="ipamResourceDiscoveryId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ipam_id: builtins.str,
        ipam_resource_discovery_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param ipam_id: The IPAM ID.
        :param ipam_resource_discovery_id: The resource discovery ID.
        :param tags: A tag is a label that you assign to an AWS resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd4a98893481afc827d51d87886f223e1b30f0a19b4c90a338e76e2be3699926)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMResourceDiscoveryAssociationProps(
            ipam_id=ipam_id,
            ipam_resource_discovery_id=ipam_resource_discovery_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5d646cf54c4b619a5fd65d31cad194a8f982e5f38dfb0cf292dfad80fee1a230)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5951c60c7996eb2fc43622794faab197c29acd8a3e97dc08cead3a0a5a90617f)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamArn")
    def attr_ipam_arn(self) -> builtins.str:
        '''The IPAM ARN.

        :cloudformationAttribute: IpamArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamRegion")
    def attr_ipam_region(self) -> builtins.str:
        '''The IPAM home Region.

        :cloudformationAttribute: IpamRegion
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamRegion"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamResourceDiscoveryAssociationArn")
    def attr_ipam_resource_discovery_association_arn(self) -> builtins.str:
        '''The resource discovery association ARN.

        :cloudformationAttribute: IpamResourceDiscoveryAssociationArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamResourceDiscoveryAssociationArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamResourceDiscoveryAssociationId")
    def attr_ipam_resource_discovery_association_id(self) -> builtins.str:
        '''The resource discovery association ID.

        :cloudformationAttribute: IpamResourceDiscoveryAssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamResourceDiscoveryAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="attrIsDefault")
    def attr_is_default(self) -> _IResolvable_da3f097b:
        '''Defines if the resource discovery is the default.

        When you create an IPAM, a default resource discovery is created for your IPAM and it's associated with your IPAM.

        :cloudformationAttribute: IsDefault
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrIsDefault"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The owner ID.

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceDiscoveryStatus")
    def attr_resource_discovery_status(self) -> builtins.str:
        '''The resource discovery status.

        - ``active`` - Connection or permissions required to read the results of the resource discovery are intact.
        - ``not-found`` - Connection or permissions required to read the results of the resource discovery are broken. This may happen if the owner of the resource discovery stopped sharing it or deleted the resource discovery. Verify the resource discovery still exists and the AWS RAM resource share is still intact.

        :cloudformationAttribute: ResourceDiscoveryStatus
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceDiscoveryStatus"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The lifecycle state of the association when you associate or disassociate a resource discovery.

        - ``associate-in-progress`` - Resource discovery is being associated.
        - ``associate-complete`` - Resource discovery association is complete.
        - ``associate-failed`` - Resource discovery association has failed.
        - ``disassociate-in-progress`` - Resource discovery is being disassociated.
        - ``disassociate-complete`` - Resource discovery disassociation is complete.
        - ``disassociate-failed`` - Resource discovery disassociation has failed.
        - ``isolate-in-progress`` - AWS account that created the resource discovery association has been removed and the resource discovery associatation is being isolated.
        - ``isolate-complete`` - Resource discovery isolation is complete..
        - ``restore-in-progress`` - Resource discovery is being restored.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="ipamId")
    def ipam_id(self) -> builtins.str:
        '''The IPAM ID.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamId"))

    @ipam_id.setter
    def ipam_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__80ac0a63190b6b72f9c08f4e9f0385b95f34cd13976099a905c32fc72b026673)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamId", value)

    @builtins.property
    @jsii.member(jsii_name="ipamResourceDiscoveryId")
    def ipam_resource_discovery_id(self) -> builtins.str:
        '''The resource discovery ID.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamResourceDiscoveryId"))

    @ipam_resource_discovery_id.setter
    def ipam_resource_discovery_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__931c3839652bb78ab222d06df9528610f9555016f5ff9eac39dff5cf4121e59b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamResourceDiscoveryId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''A tag is a label that you assign to an AWS resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6375db80366aea82179422e8233a2b6fa062438e1066f47a1a85e8f62d5ee914)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMResourceDiscoveryAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "ipam_id": "ipamId",
        "ipam_resource_discovery_id": "ipamResourceDiscoveryId",
        "tags": "tags",
    },
)
class CfnIPAMResourceDiscoveryAssociationProps:
    def __init__(
        self,
        *,
        ipam_id: builtins.str,
        ipam_resource_discovery_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMResourceDiscoveryAssociation``.

        :param ipam_id: The IPAM ID.
        :param ipam_resource_discovery_id: The resource discovery ID.
        :param tags: A tag is a label that you assign to an AWS resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscoveryassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMResource_discovery_association_props = ec2.CfnIPAMResourceDiscoveryAssociationProps(
                ipam_id="ipamId",
                ipam_resource_discovery_id="ipamResourceDiscoveryId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb361397fe1ad5d7ac1eae95f3c6ef9c0ab8eb533a0492e48d2544ac255d9a84)
            check_type(argname="argument ipam_id", value=ipam_id, expected_type=type_hints["ipam_id"])
            check_type(argname="argument ipam_resource_discovery_id", value=ipam_resource_discovery_id, expected_type=type_hints["ipam_resource_discovery_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipam_id": ipam_id,
            "ipam_resource_discovery_id": ipam_resource_discovery_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def ipam_id(self) -> builtins.str:
        '''The IPAM ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscoveryassociation.html#cfn-ec2-ipamresourcediscoveryassociation-ipamid
        '''
        result = self._values.get("ipam_id")
        assert result is not None, "Required property 'ipam_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ipam_resource_discovery_id(self) -> builtins.str:
        '''The resource discovery ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscoveryassociation.html#cfn-ec2-ipamresourcediscoveryassociation-ipamresourcediscoveryid
        '''
        result = self._values.get("ipam_resource_discovery_id")
        assert result is not None, "Required property 'ipam_resource_discovery_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''A tag is a label that you assign to an AWS resource.

        Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscoveryassociation.html#cfn-ec2-ipamresourcediscoveryassociation-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMResourceDiscoveryAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMResourceDiscoveryProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "operating_regions": "operatingRegions",
        "tags": "tags",
    },
)
class CfnIPAMResourceDiscoveryProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMResourceDiscovery.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMResourceDiscovery``.

        :param description: The resource discovery description.
        :param operating_regions: The operating Regions for the resource discovery. Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.
        :param tags: A tag is a label that you assign to an AWS resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscovery.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMResource_discovery_props = ec2.CfnIPAMResourceDiscoveryProps(
                description="description",
                operating_regions=[ec2.CfnIPAMResourceDiscovery.IpamOperatingRegionProperty(
                    region_name="regionName"
                )],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f109dd2c7d7c94b25622dd13433c13abb153fa5092da9272630e94ba4005e9e2)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument operating_regions", value=operating_regions, expected_type=type_hints["operating_regions"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if operating_regions is not None:
            self._values["operating_regions"] = operating_regions
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The resource discovery description.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscovery.html#cfn-ec2-ipamresourcediscovery-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def operating_regions(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMResourceDiscovery.IpamOperatingRegionProperty]]]]:
        '''The operating Regions for the resource discovery.

        Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs. IPAM only discovers and monitors resources in the AWS Regions you select as operating Regions.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscovery.html#cfn-ec2-ipamresourcediscovery-operatingregions
        '''
        result = self._values.get("operating_regions")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMResourceDiscovery.IpamOperatingRegionProperty]]]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''A tag is a label that you assign to an AWS resource.

        Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your AWS costs.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamresourcediscovery.html#cfn-ec2-ipamresourcediscovery-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMResourceDiscoveryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnIPAMScope(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMScope",
):
    '''In IPAM, a scope is the highest-level container within IPAM.

    An IPAM contains two default scopes. Each scope represents the IP space for a single network. The private scope is intended for all private IP address space. The public scope is intended for all public IP address space. Scopes enable you to reuse IP addresses across multiple unconnected networks without causing IP address overlap or conflict.

    For more information, see `How IPAM works <https://docs.aws.amazon.com//vpc/latest/ipam/how-it-works-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
    :cloudformationResource: AWS::EC2::IPAMScope
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_iPAMScope = ec2.CfnIPAMScope(self, "MyCfnIPAMScope",
            ipam_id="ipamId",
        
            # the properties below are optional
            description="description",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ipam_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param ipam_id: The ID of the IPAM for which you're creating this scope.
        :param description: The description of the scope.
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0261d3b2f94da048fb1c8fbab861a99b9ba787a6bfde7f2b8d1f37d939f92ebc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnIPAMScopeProps(ipam_id=ipam_id, description=description, tags=tags)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__33ce1a601432c36a76445a195729508d4810ba6d52ceb4763cb3fd1abcb95a13)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3cd844c7f08104cfc38ec0de8271330db006d54de894a5aecb4b5df4be23d9a4)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrArn")
    def attr_arn(self) -> builtins.str:
        '''The ARN of the scope.

        :cloudformationAttribute: Arn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamArn")
    def attr_ipam_arn(self) -> builtins.str:
        '''The ARN of an IPAM.

        :cloudformationAttribute: IpamArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamArn"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamScopeId")
    def attr_ipam_scope_id(self) -> builtins.str:
        '''The ID of an IPAM scope.

        :cloudformationAttribute: IpamScopeId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamScopeId"))

    @builtins.property
    @jsii.member(jsii_name="attrIpamScopeType")
    def attr_ipam_scope_type(self) -> builtins.str:
        '''The type of the scope.

        :cloudformationAttribute: IpamScopeType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrIpamScopeType"))

    @builtins.property
    @jsii.member(jsii_name="attrIsDefault")
    def attr_is_default(self) -> _IResolvable_da3f097b:
        '''Defines if the scope is the default scope or not.

        :cloudformationAttribute: IsDefault
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrIsDefault"))

    @builtins.property
    @jsii.member(jsii_name="attrPoolCount")
    def attr_pool_count(self) -> jsii.Number:
        '''The number of pools in a scope.

        :cloudformationAttribute: PoolCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrPoolCount"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="ipamId")
    def ipam_id(self) -> builtins.str:
        '''The ID of the IPAM for which you're creating this scope.'''
        return typing.cast(builtins.str, jsii.get(self, "ipamId"))

    @ipam_id.setter
    def ipam_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a137849a9414fb5992c1c8ec89ee6f38207de6759ce6e114997836c7bb0d5224)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipamId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the scope.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5e625dceaf4a24f11f92d07008100ff002df387ed10ce5325c3ecc3a808d1a2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__360b636f6d0ffe468b2eece7c5abcc5b35a5f65fe82b521469bd1343e359042b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnIPAMScopeProps",
    jsii_struct_bases=[],
    name_mapping={"ipam_id": "ipamId", "description": "description", "tags": "tags"},
)
class CfnIPAMScopeProps:
    def __init__(
        self,
        *,
        ipam_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnIPAMScope``.

        :param ipam_id: The ID of the IPAM for which you're creating this scope.
        :param description: The description of the scope.
        :param tags: The key/value combination of a tag assigned to the resource. Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_iPAMScope_props = ec2.CfnIPAMScopeProps(
                ipam_id="ipamId",
            
                # the properties below are optional
                description="description",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e05ab093185baf1469a05b4c1ff6279a87a1d8d1be6a9625a64b495f21874f24)
            check_type(argname="argument ipam_id", value=ipam_id, expected_type=type_hints["ipam_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipam_id": ipam_id,
        }
        if description is not None:
            self._values["description"] = description
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def ipam_id(self) -> builtins.str:
        '''The ID of the IPAM for which you're creating this scope.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html#cfn-ec2-ipamscope-ipamid
        '''
        result = self._values.get("ipam_id")
        assert result is not None, "Required property 'ipam_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the scope.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html#cfn-ec2-ipamscope-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The key/value combination of a tag assigned to the resource.

        Use the tag key in the filter name and the tag value as the filter value. For example, to find all resources that have a tag with the key ``Owner`` and the value ``TeamA`` , specify ``tag:Owner`` for the filter name and ``TeamA`` for the filter value.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html#cfn-ec2-ipamscope-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnIPAMScopeProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnInstance(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnInstance",
):
    '''Specifies an EC2 instance.

    If an Elastic IP address is attached to your instance, AWS CloudFormation reattaches the Elastic IP address after it updates the instance. For more information about updating stacks, see `AWS CloudFormation Stacks Updates <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html
    :cloudformationResource: AWS::EC2::Instance
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_instance = ec2.CfnInstance(self, "MyCfnInstance",
            additional_info="additionalInfo",
            affinity="affinity",
            availability_zone="availabilityZone",
            block_device_mappings=[ec2.CfnInstance.BlockDeviceMappingProperty(
                device_name="deviceName",
        
                # the properties below are optional
                ebs=ec2.CfnInstance.EbsProperty(
                    delete_on_termination=False,
                    encrypted=False,
                    iops=123,
                    kms_key_id="kmsKeyId",
                    snapshot_id="snapshotId",
                    volume_size=123,
                    volume_type="volumeType"
                ),
                no_device=ec2.CfnInstance.NoDeviceProperty(),
                virtual_name="virtualName"
            )],
            cpu_options=ec2.CfnInstance.CpuOptionsProperty(
                core_count=123,
                threads_per_core=123
            ),
            credit_specification=ec2.CfnInstance.CreditSpecificationProperty(
                cpu_credits="cpuCredits"
            ),
            disable_api_termination=False,
            ebs_optimized=False,
            elastic_gpu_specifications=[ec2.CfnInstance.ElasticGpuSpecificationProperty(
                type="type"
            )],
            elastic_inference_accelerators=[ec2.CfnInstance.ElasticInferenceAcceleratorProperty(
                type="type",
        
                # the properties below are optional
                count=123
            )],
            enclave_options=ec2.CfnInstance.EnclaveOptionsProperty(
                enabled=False
            ),
            hibernation_options=ec2.CfnInstance.HibernationOptionsProperty(
                configured=False
            ),
            host_id="hostId",
            host_resource_group_arn="hostResourceGroupArn",
            iam_instance_profile="iamInstanceProfile",
            image_id="imageId",
            instance_initiated_shutdown_behavior="instanceInitiatedShutdownBehavior",
            instance_type="instanceType",
            ipv6_address_count=123,
            ipv6_addresses=[ec2.CfnInstance.InstanceIpv6AddressProperty(
                ipv6_address="ipv6Address"
            )],
            kernel_id="kernelId",
            key_name="keyName",
            launch_template=ec2.CfnInstance.LaunchTemplateSpecificationProperty(
                version="version",
        
                # the properties below are optional
                launch_template_id="launchTemplateId",
                launch_template_name="launchTemplateName"
            ),
            license_specifications=[ec2.CfnInstance.LicenseSpecificationProperty(
                license_configuration_arn="licenseConfigurationArn"
            )],
            monitoring=False,
            network_interfaces=[ec2.CfnInstance.NetworkInterfaceProperty(
                device_index="deviceIndex",
        
                # the properties below are optional
                associate_carrier_ip_address=False,
                associate_public_ip_address=False,
                delete_on_termination=False,
                description="description",
                group_set=["groupSet"],
                ipv6_address_count=123,
                ipv6_addresses=[ec2.CfnInstance.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )],
                network_interface_id="networkInterfaceId",
                private_ip_address="privateIpAddress",
                private_ip_addresses=[ec2.CfnInstance.PrivateIpAddressSpecificationProperty(
                    primary=False,
                    private_ip_address="privateIpAddress"
                )],
                secondary_private_ip_address_count=123,
                subnet_id="subnetId"
            )],
            placement_group_name="placementGroupName",
            private_dns_name_options=ec2.CfnInstance.PrivateDnsNameOptionsProperty(
                enable_resource_name_dns_aaaa_record=False,
                enable_resource_name_dns_aRecord=False,
                hostname_type="hostnameType"
            ),
            private_ip_address="privateIpAddress",
            propagate_tags_to_volume_on_creation=False,
            ramdisk_id="ramdiskId",
            security_group_ids=["securityGroupIds"],
            security_groups=["securityGroups"],
            source_dest_check=False,
            ssm_associations=[ec2.CfnInstance.SsmAssociationProperty(
                document_name="documentName",
        
                # the properties below are optional
                association_parameters=[ec2.CfnInstance.AssociationParameterProperty(
                    key="key",
                    value=["value"]
                )]
            )],
            subnet_id="subnetId",
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            tenancy="tenancy",
            user_data="userData",
            volumes=[ec2.CfnInstance.VolumeProperty(
                device="device",
                volume_id="volumeId"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        additional_info: typing.Optional[builtins.str] = None,
        affinity: typing.Optional[builtins.str] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.BlockDeviceMappingProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.CpuOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.CreditSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.ElasticGpuSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.ElasticInferenceAcceleratorProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.EnclaveOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.HibernationOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        host_id: typing.Optional[builtins.str] = None,
        host_resource_group_arn: typing.Optional[builtins.str] = None,
        iam_instance_profile: typing.Optional[builtins.str] = None,
        image_id: typing.Optional[builtins.str] = None,
        instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional[builtins.str] = None,
        ipv6_address_count: typing.Optional[jsii.Number] = None,
        ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.InstanceIpv6AddressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        kernel_id: typing.Optional[builtins.str] = None,
        key_name: typing.Optional[builtins.str] = None,
        launch_template: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.LaunchTemplateSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.LicenseSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        monitoring: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.NetworkInterfaceProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        placement_group_name: typing.Optional[builtins.str] = None,
        private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.PrivateDnsNameOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        propagate_tags_to_volume_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ramdisk_id: typing.Optional[builtins.str] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
        source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ssm_associations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.SsmAssociationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        subnet_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
        user_data: typing.Optional[builtins.str] = None,
        volumes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.VolumeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param additional_info: This property is reserved for internal use. If you use it, the stack fails with this error: ``Bad property set: [Testing this property] (Service: AmazonEC2; Status Code: 400; Error Code: InvalidParameterCombination; Request ID: 0XXXXXX-49c7-4b40-8bcc-76885dcXXXXX)`` .
        :param affinity: Indicates whether the instance is associated with a dedicated host. If you want the instance to always restart on the same host on which it was launched, specify ``host`` . If you want the instance to restart on any available host, but try to launch onto the last host it ran on (on a best-effort basis), specify ``default`` .
        :param availability_zone: The Availability Zone of the instance. If not specified, an Availability Zone will be automatically chosen for you based on the load balancing criteria for the Region. This parameter is not supported by `DescribeImageAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html>`_ .
        :param block_device_mappings: The block device mapping entries that defines the block devices to attach to the instance at launch. By default, the block devices specified in the block device mapping for the AMI are used. You can override the AMI block device mapping using the instance block device mapping. For the root volume, you can override only the volume size, volume type, volume encryption settings, and the ``DeleteOnTermination`` setting. .. epigraph:: After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
        :param cpu_options: The CPU options for the instance. For more information, see `Optimize CPU options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
        :param credit_specification: The credit option for CPU usage of the burstable performance instance. Valid values are ``standard`` and ``unlimited`` . To change this attribute after launch, use `ModifyInstanceCreditSpecification <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceCreditSpecification.html>`_ . For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ in the *Amazon EC2 User Guide* . Default: ``standard`` (T2 instances) or ``unlimited`` (T3/T3a/T4g instances) For T3 instances with ``host`` tenancy, only ``standard`` is supported.
        :param disable_api_termination: If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can. To change this attribute after launch, use `ModifyInstanceAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html>`_ . Alternatively, if you set ``InstanceInitiatedShutdownBehavior`` to ``terminate`` , you can terminate the instance by running the shutdown command from the instance. Default: ``false``
        :param ebs_optimized: Indicates whether the instance is optimized for Amazon EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance. Default: ``false``
        :param elastic_gpu_specifications: Deprecated. .. epigraph:: Amazon Elastic Graphics reached end of life on January 8, 2024. For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.
        :param elastic_inference_accelerators: An elastic inference accelerator to associate with the instance. Elastic inference accelerators are a resource you can attach to your Amazon EC2 instances to accelerate your Deep Learning (DL) inference workloads. You cannot specify accelerators from different generations in the same request. .. epigraph:: Starting April 15, 2023, AWS will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, Amazon ECS, or Amazon EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.
        :param enclave_options: Indicates whether the instance is enabled for AWS Nitro Enclaves.
        :param hibernation_options: Indicates whether an instance is enabled for hibernation. This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html>`_ . For more information, see `Hibernate your instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon EC2 User Guide* . You can't enable hibernation and AWS Nitro Enclaves on the same instance.
        :param host_id: If you specify host for the ``Affinity`` property, the ID of a dedicated host that the instance is associated with. If you don't specify an ID, Amazon EC2 launches the instance onto any available, compatible dedicated host in your account. This type of launch is called an untargeted launch. Note that for untargeted launches, you must have a compatible, dedicated host available to successfully launch instances.
        :param host_resource_group_arn: The ARN of the host resource group in which to launch the instances. If you specify a host resource group ARN, omit the *Tenancy* parameter or set it to ``host`` .
        :param iam_instance_profile: The name of an IAM instance profile. To create a new IAM instance profile, use the `AWS::IAM::InstanceProfile <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html>`_ resource.
        :param image_id: The ID of the AMI. An AMI ID is required to launch an instance and must be specified here or in a launch template.
        :param instance_initiated_shutdown_behavior: Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Default: ``stop``
        :param instance_type: The instance type. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* . When you change your EBS-backed instance type, instance restart or replacement behavior depends on the instance type compatibility between the old and new types. An instance with an instance store volume as the root volume is always replaced. For more information, see `Change the instance type <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html>`_ in the *Amazon EC2 User Guide* .
        :param ipv6_address_count: The number of IPv6 addresses to associate with the primary network interface. Amazon EC2 chooses the IPv6 addresses from the range of your subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch. You cannot specify this option and the network interfaces option in the same request.
        :param ipv6_addresses: The IPv6 addresses from the range of the subnet to associate with the primary network interface. You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch. You cannot specify this option and the network interfaces option in the same request.
        :param kernel_id: The ID of the kernel. .. epigraph:: We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .
        :param key_name: The name of the key pair. You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ . .. epigraph:: If you do not specify a key pair, you can't connect to the instance unless you choose an AMI that is configured to allow users another way to log in.
        :param launch_template: The launch template to use to launch the instances. Any parameters that you specify in the AWS CloudFormation template override the same parameters in the launch template. You can specify either the name or ID of a launch template, but not both.
        :param license_specifications: The license configurations.
        :param monitoring: Specifies whether detailed monitoring is enabled for the instance. Specify ``true`` to enable detailed monitoring. Otherwise, basic monitoring is enabled. For more information about detailed monitoring, see `Enable or turn off detailed monitoring for your instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html>`_ in the *Amazon EC2 User Guide* .
        :param network_interfaces: The network interfaces to associate with the instance. .. epigraph:: If you use this property to point to a network interface, you must terminate the original interface before attaching a new one to allow the update of the instance to succeed. If this resource has a public IP address and is also in a VPC that is defined in the same template, you must use the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ to declare a dependency on the VPC-gateway attachment.
        :param placement_group_name: The name of an existing placement group that you want to launch the instance into (cluster | partition | spread).
        :param private_dns_name_options: The options for the instance hostname.
        :param private_ip_address: The primary IPv4 address. You must specify a value from the IPv4 address range of the subnet. Only one private IP address can be designated as primary. You can't specify this option if you've specified the option to designate a private IP address as the primary IP address in a network interface specification. You cannot specify this option if you're launching more than one instance in the request. You cannot specify this option and the network interfaces option in the same request. If you make an update to an instance that requires replacement, you must assign a new private IP address. During a replacement, AWS CloudFormation creates a new instance but doesn't delete the old instance until the stack has successfully updated. If the stack update fails, AWS CloudFormation uses the old instance to roll back the stack to the previous working state. The old and new instances cannot have the same private IP address.
        :param propagate_tags_to_volume_on_creation: Indicates whether to assign the tags from the instance to all of the volumes attached to the instance at launch. If you specify ``true`` and you assign tags to the instance, those tags are automatically assigned to all of the volumes that you attach to the instance at launch. If you specify ``false`` , those tags are not assigned to the attached volumes.
        :param ramdisk_id: The ID of the RAM disk to select. Some kernels require additional drivers at launch. Check the kernel requirements for information about whether you need to specify a RAM disk. To find kernel requirements, go to the AWS Resource Center and search for the kernel ID. .. epigraph:: We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .
        :param security_group_ids: The IDs of the security groups. You can specify the IDs of existing security groups and references to resources created by the stack template. If you specify a network interface, you must specify any security groups as part of the network interface.
        :param security_groups: [Default VPC] The names of the security groups. For a nondefault VPC, you must use security group IDs instead. You cannot specify this option and the network interfaces option in the same request. The list can contain both the name of existing Amazon EC2 security groups or references to AWS::EC2::SecurityGroup resources created in the template. Default: Amazon EC2 uses the default security group.
        :param source_dest_check: 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.
        :param ssm_associations: The SSM `document <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ssm-document.html>`_ and parameter values in AWS Systems Manager to associate with this instance. To use this property, you must specify an IAM instance profile role for the instance. For more information, see `Create an IAM instance profile for Systems Manager <https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-configuring-access-role.html>`_ in the *AWS Systems Manager User Guide* . .. epigraph:: You can associate only one document with an instance.
        :param subnet_id: The ID of the subnet to launch the instance into. If you specify a network interface, you must specify any subnets as part of the network interface.
        :param tags: The tags to add to the instance. These tags are not applied to the EBS volumes, such as the root volume, unless `PropagateTagsToVolumeOnCreation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html#cfn-ec2-instance-propagatetagstovolumeoncreation>`_ is ``true`` .
        :param tenancy: The tenancy of the instance. An instance with a tenancy of ``dedicated`` runs on single-tenant hardware.
        :param user_data: The parameters or scripts to store as user data. Any scripts in user data are run when you launch the instance. User data is limited to 16 KB. You must provide base64-encoded text. For more information, see `Fn::Base64 <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-base64.html>`_ . If the root volume is an EBS volume and you update user data, CloudFormation restarts the instance. If the root volume is an instance store volume and you update user data, the instance is replaced.
        :param volumes: The volumes to attach to the instance.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c4a16bcac45df35102107cab13dbaea279aac225408d8ffe54a341484e92c7db)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnInstanceProps(
            additional_info=additional_info,
            affinity=affinity,
            availability_zone=availability_zone,
            block_device_mappings=block_device_mappings,
            cpu_options=cpu_options,
            credit_specification=credit_specification,
            disable_api_termination=disable_api_termination,
            ebs_optimized=ebs_optimized,
            elastic_gpu_specifications=elastic_gpu_specifications,
            elastic_inference_accelerators=elastic_inference_accelerators,
            enclave_options=enclave_options,
            hibernation_options=hibernation_options,
            host_id=host_id,
            host_resource_group_arn=host_resource_group_arn,
            iam_instance_profile=iam_instance_profile,
            image_id=image_id,
            instance_initiated_shutdown_behavior=instance_initiated_shutdown_behavior,
            instance_type=instance_type,
            ipv6_address_count=ipv6_address_count,
            ipv6_addresses=ipv6_addresses,
            kernel_id=kernel_id,
            key_name=key_name,
            launch_template=launch_template,
            license_specifications=license_specifications,
            monitoring=monitoring,
            network_interfaces=network_interfaces,
            placement_group_name=placement_group_name,
            private_dns_name_options=private_dns_name_options,
            private_ip_address=private_ip_address,
            propagate_tags_to_volume_on_creation=propagate_tags_to_volume_on_creation,
            ramdisk_id=ramdisk_id,
            security_group_ids=security_group_ids,
            security_groups=security_groups,
            source_dest_check=source_dest_check,
            ssm_associations=ssm_associations,
            subnet_id=subnet_id,
            tags=tags,
            tenancy=tenancy,
            user_data=user_data,
            volumes=volumes,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0f05b7732316f828754605c3154cbf0ccd005a66cccda9fe936bd6d833ff8d6)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85b8979157afc2218535ae732d6c76f3ef2ed9f6e1bfca4fb82fc41d1c824981)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAvailabilityZone")
    def attr_availability_zone(self) -> builtins.str:
        '''The Availability Zone where the specified instance is launched. For example: ``us-east-1b`` .

        You can retrieve a list of all Availability Zones for a Region by using the `Fn::GetAZs <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getavailabilityzones.html>`_ intrinsic function.

        :cloudformationAttribute: AvailabilityZone
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the instance.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrPrivateDnsName")
    def attr_private_dns_name(self) -> builtins.str:
        '''The private DNS name of the specified instance.

        For example: ``ip-10-24-34-0.ec2.internal`` .

        :cloudformationAttribute: PrivateDnsName
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrivateDnsName"))

    @builtins.property
    @jsii.member(jsii_name="attrPrivateIp")
    def attr_private_ip(self) -> builtins.str:
        '''The private IP address of the specified instance.

        For example: ``10.24.34.0`` .

        :cloudformationAttribute: PrivateIp
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrivateIp"))

    @builtins.property
    @jsii.member(jsii_name="attrPublicDnsName")
    def attr_public_dns_name(self) -> builtins.str:
        '''The public DNS name of the specified instance.

        For example: ``ec2-107-20-50-45.compute-1.amazonaws.com`` .

        :cloudformationAttribute: PublicDnsName
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPublicDnsName"))

    @builtins.property
    @jsii.member(jsii_name="attrPublicIp")
    def attr_public_ip(self) -> builtins.str:
        '''The public IP address of the specified instance.

        For example: ``192.0.2.0`` .

        :cloudformationAttribute: PublicIp
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPublicIp"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="additionalInfo")
    def additional_info(self) -> typing.Optional[builtins.str]:
        '''This property is reserved for internal use.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "additionalInfo"))

    @additional_info.setter
    def additional_info(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87e90f9accfae6c3bbba01423ffc099c7fec4f1ba15653c6765614277a901683)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "additionalInfo", value)

    @builtins.property
    @jsii.member(jsii_name="affinity")
    def affinity(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the instance is associated with a dedicated host.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "affinity"))

    @affinity.setter
    def affinity(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1ae241269dda91526f67dbe13022238c1375289dc9d01f92d085bee3e800112)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "affinity", value)

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone of the instance.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "availabilityZone"))

    @availability_zone.setter
    def availability_zone(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3925e50c070f64377e9a34e2cda7a4641467c01b8d42f1d691a657f2d5c5fe13)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZone", value)

    @builtins.property
    @jsii.member(jsii_name="blockDeviceMappings")
    def block_device_mappings(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.BlockDeviceMappingProperty"]]]]:
        '''The block device mapping entries that defines the block devices to attach to the instance at launch.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.BlockDeviceMappingProperty"]]]], jsii.get(self, "blockDeviceMappings"))

    @block_device_mappings.setter
    def block_device_mappings(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.BlockDeviceMappingProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__042c9c27e1e37cd7271cb5ae943c9a8c073af042fccac0055a0cc2ef934600c4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "blockDeviceMappings", value)

    @builtins.property
    @jsii.member(jsii_name="cpuOptions")
    def cpu_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CpuOptionsProperty"]]:
        '''The CPU options for the instance.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CpuOptionsProperty"]], jsii.get(self, "cpuOptions"))

    @cpu_options.setter
    def cpu_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CpuOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cbc71a85ca64051e0a3d92cceea1b162cbd10827aecc7ee6cbe1a4894f804f49)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cpuOptions", value)

    @builtins.property
    @jsii.member(jsii_name="creditSpecification")
    def credit_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CreditSpecificationProperty"]]:
        '''The credit option for CPU usage of the burstable performance instance.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CreditSpecificationProperty"]], jsii.get(self, "creditSpecification"))

    @credit_specification.setter
    def credit_specification(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.CreditSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba159afaa93d1cfa03142545ac6c2fc45b8a873b18cbafacb05e03232921f72f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "creditSpecification", value)

    @builtins.property
    @jsii.member(jsii_name="disableApiTermination")
    def disable_api_termination(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API;'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "disableApiTermination"))

    @disable_api_termination.setter
    def disable_api_termination(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe5e9e392f3feb0f4a077cd9f8e5c6a41b3e32b4e827ada98d41629c5c0e3476)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "disableApiTermination", value)

    @builtins.property
    @jsii.member(jsii_name="ebsOptimized")
    def ebs_optimized(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the instance is optimized for Amazon EBS I/O.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "ebsOptimized"))

    @ebs_optimized.setter
    def ebs_optimized(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1e115e37b678459d0e4b676dbfec5f9ff8d4ef38f062cb82724d09d3ed19e378)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ebsOptimized", value)

    @builtins.property
    @jsii.member(jsii_name="elasticGpuSpecifications")
    def elastic_gpu_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticGpuSpecificationProperty"]]]]:
        '''Deprecated.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticGpuSpecificationProperty"]]]], jsii.get(self, "elasticGpuSpecifications"))

    @elastic_gpu_specifications.setter
    def elastic_gpu_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticGpuSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8f036dcb6edd2c56f6b2a21215980a3ab4ec3d06dc0bc3ae5a1d45dc2eebda93)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "elasticGpuSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="elasticInferenceAccelerators")
    def elastic_inference_accelerators(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticInferenceAcceleratorProperty"]]]]:
        '''An elastic inference accelerator to associate with the instance.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticInferenceAcceleratorProperty"]]]], jsii.get(self, "elasticInferenceAccelerators"))

    @elastic_inference_accelerators.setter
    def elastic_inference_accelerators(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.ElasticInferenceAcceleratorProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00f9dd3f9cef8f4d1d69547f4ca18f4f301df8477a197bf754b9ca0af4488009)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "elasticInferenceAccelerators", value)

    @builtins.property
    @jsii.member(jsii_name="enclaveOptions")
    def enclave_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.EnclaveOptionsProperty"]]:
        '''Indicates whether the instance is enabled for AWS Nitro Enclaves.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.EnclaveOptionsProperty"]], jsii.get(self, "enclaveOptions"))

    @enclave_options.setter
    def enclave_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.EnclaveOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7958686f1c567225ae7cc8d2ccee36dfef9a479396391ee1ff2f65f1d29e27da)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enclaveOptions", value)

    @builtins.property
    @jsii.member(jsii_name="hibernationOptions")
    def hibernation_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.HibernationOptionsProperty"]]:
        '''Indicates whether an instance is enabled for hibernation.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.HibernationOptionsProperty"]], jsii.get(self, "hibernationOptions"))

    @hibernation_options.setter
    def hibernation_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.HibernationOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48dff62efe0ddb66f23842a25532fe4bb39c9bab8f8315467e234d6ddd6ea5d6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "hibernationOptions", value)

    @builtins.property
    @jsii.member(jsii_name="hostId")
    def host_id(self) -> typing.Optional[builtins.str]:
        '''If you specify host for the ``Affinity`` property, the ID of a dedicated host that the instance is associated with.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "hostId"))

    @host_id.setter
    def host_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1df2bec42892b2e3246b2f3fa638eff1aec0b1c94ecf49227f090b0a0ee3695d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "hostId", value)

    @builtins.property
    @jsii.member(jsii_name="hostResourceGroupArn")
    def host_resource_group_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the host resource group in which to launch the instances.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "hostResourceGroupArn"))

    @host_resource_group_arn.setter
    def host_resource_group_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f600392e6229a8a280df02b144c760ceafc21ffbd5e40af6d0c6454734c69e2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "hostResourceGroupArn", value)

    @builtins.property
    @jsii.member(jsii_name="iamInstanceProfile")
    def iam_instance_profile(self) -> typing.Optional[builtins.str]:
        '''The name of an IAM instance profile.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "iamInstanceProfile"))

    @iam_instance_profile.setter
    def iam_instance_profile(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b113f4afc1e19b58666c23839c1aeca48a39a1726f5969c0a2904f6dbc642e4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "iamInstanceProfile", value)

    @builtins.property
    @jsii.member(jsii_name="imageId")
    def image_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the AMI.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "imageId"))

    @image_id.setter
    def image_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__792c60e584d269c734eafdde6ac59c5e48d8d397a6c64c1ff02a7432401c0c86)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "imageId", value)

    @builtins.property
    @jsii.member(jsii_name="instanceInitiatedShutdownBehavior")
    def instance_initiated_shutdown_behavior(self) -> typing.Optional[builtins.str]:
        '''Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceInitiatedShutdownBehavior"))

    @instance_initiated_shutdown_behavior.setter
    def instance_initiated_shutdown_behavior(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__de1eb323a410b41bd5747356127172e6eb92c0513303e39ab842275271ac4beb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceInitiatedShutdownBehavior", value)

    @builtins.property
    @jsii.member(jsii_name="instanceType")
    def instance_type(self) -> typing.Optional[builtins.str]:
        '''The instance type.

        For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceType"))

    @instance_type.setter
    def instance_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d036709eb1e4dae59f293a3840ac6d3d1bd738fc68ac65984c721a25ec275a3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceType", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6AddressCount")
    def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv6 addresses to associate with the primary network interface.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6AddressCount"))

    @ipv6_address_count.setter
    def ipv6_address_count(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51667b6f819a586cf3b104b3b1ef74435861fdf7fb92c3c78035abbe9b31bd0a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6AddressCount", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6Addresses")
    def ipv6_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.InstanceIpv6AddressProperty"]]]]:
        '''The IPv6 addresses from the range of the subnet to associate with the primary network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.InstanceIpv6AddressProperty"]]]], jsii.get(self, "ipv6Addresses"))

    @ipv6_addresses.setter
    def ipv6_addresses(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.InstanceIpv6AddressProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f309ef468fcaf7376083a9aeafea7463099a28d3ebdff9ba4f7938131d14215)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6Addresses", value)

    @builtins.property
    @jsii.member(jsii_name="kernelId")
    def kernel_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the kernel.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "kernelId"))

    @kernel_id.setter
    def kernel_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6c3bcf0d33bd1fece9e30b9f9c9576f9c02d615eb5b0b3de5f8e2fa25dc40c22)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "kernelId", value)

    @builtins.property
    @jsii.member(jsii_name="keyName")
    def key_name(self) -> typing.Optional[builtins.str]:
        '''The name of the key pair.

        You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ .
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "keyName"))

    @key_name.setter
    def key_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7275a8c334430bc87a69288a681675c1b8cefd440667eb9193e60dfe3aa6afc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "keyName", value)

    @builtins.property
    @jsii.member(jsii_name="launchTemplate")
    def launch_template(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.LaunchTemplateSpecificationProperty"]]:
        '''The launch template to use to launch the instances.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.LaunchTemplateSpecificationProperty"]], jsii.get(self, "launchTemplate"))

    @launch_template.setter
    def launch_template(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.LaunchTemplateSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00bc577e0b8cf9dbe1398dc08451a7bd5d8e5d031d9d347f5556526acdca0223)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "launchTemplate", value)

    @builtins.property
    @jsii.member(jsii_name="licenseSpecifications")
    def license_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.LicenseSpecificationProperty"]]]]:
        '''The license configurations.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.LicenseSpecificationProperty"]]]], jsii.get(self, "licenseSpecifications"))

    @license_specifications.setter
    def license_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.LicenseSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cc2686e45ed4c6d1878a8ae7e28861e3db1d532776cefb8db34c5911f65e2d55)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "licenseSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="monitoring")
    def monitoring(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Specifies whether detailed monitoring is enabled for the instance.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "monitoring"))

    @monitoring.setter
    def monitoring(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7a0da44bb62f454316060622acd522d46ed58c088bae4a9f6249bcf6deca5588)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "monitoring", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaces")
    def network_interfaces(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.NetworkInterfaceProperty"]]]]:
        '''The network interfaces to associate with the instance.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.NetworkInterfaceProperty"]]]], jsii.get(self, "networkInterfaces"))

    @network_interfaces.setter
    def network_interfaces(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.NetworkInterfaceProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4cf49de28342f59b82e13651c3b5628d995d1e2dbe8f2e21bb504f69ebdc26a5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaces", value)

    @builtins.property
    @jsii.member(jsii_name="placementGroupName")
    def placement_group_name(self) -> typing.Optional[builtins.str]:
        '''The name of an existing placement group that you want to launch the instance into (cluster | partition | spread).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "placementGroupName"))

    @placement_group_name.setter
    def placement_group_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b94a126a071c508f79ee90f5bf58c4128b01fe4e85c97c2a9111f0fd16fdbd4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "placementGroupName", value)

    @builtins.property
    @jsii.member(jsii_name="privateDnsNameOptions")
    def private_dns_name_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.PrivateDnsNameOptionsProperty"]]:
        '''The options for the instance hostname.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.PrivateDnsNameOptionsProperty"]], jsii.get(self, "privateDnsNameOptions"))

    @private_dns_name_options.setter
    def private_dns_name_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.PrivateDnsNameOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__947893fdfa4f834f21c670b592c49513bfa62e60013396a6b131adbcf5435dab)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateDnsNameOptions", value)

    @builtins.property
    @jsii.member(jsii_name="privateIpAddress")
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The primary IPv4 address.

        You must specify a value from the IPv4 address range of the subnet.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "privateIpAddress"))

    @private_ip_address.setter
    def private_ip_address(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a71c1eafde77ef22d4765745762298efe1282a9aa3a65f7cb6bc5a4c165737ca)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateIpAddress", value)

    @builtins.property
    @jsii.member(jsii_name="propagateTagsToVolumeOnCreation")
    def propagate_tags_to_volume_on_creation(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to assign the tags from the instance to all of the volumes attached to the instance at launch.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "propagateTagsToVolumeOnCreation"))

    @propagate_tags_to_volume_on_creation.setter
    def propagate_tags_to_volume_on_creation(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52cd42f76a076dc5b64b6059fc467932a0c45b25e4dc8b2a9df576afb335c6c2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "propagateTagsToVolumeOnCreation", value)

    @builtins.property
    @jsii.member(jsii_name="ramdiskId")
    def ramdisk_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the RAM disk to select.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ramdiskId"))

    @ramdisk_id.setter
    def ramdisk_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98b3ddcbbd89e8e3e1c57e918909b07082ecf9f399f352e21233109f94a89075)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ramdiskId", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIds")
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroupIds"))

    @security_group_ids.setter
    def security_group_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af0862bdb0b54ae68c63c8124fe2ae266f1335a875481becee1c43581305f1e0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIds", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroups")
    def security_groups(self) -> typing.Optional[typing.List[builtins.str]]:
        '''[Default VPC] The names of the security groups.

        For a nondefault VPC, you must use security group IDs instead.
        '''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroups"))

    @security_groups.setter
    def security_groups(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f5a0dbe34c0acf2c2660c25061489182d68db16e1d429f2ea8bdb5521b220f3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroups", value)

    @builtins.property
    @jsii.member(jsii_name="sourceDestCheck")
    def source_dest_check(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Enable or disable source/destination checks, which ensure that the instance is either the source or the destination of any traffic that it receives.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "sourceDestCheck"))

    @source_dest_check.setter
    def source_dest_check(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fddd8e271a5110ba1fe75e660e4da015fcfa5fed134753a58b9f68cd018766d5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceDestCheck", value)

    @builtins.property
    @jsii.member(jsii_name="ssmAssociations")
    def ssm_associations(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.SsmAssociationProperty"]]]]:
        '''The SSM `document <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ssm-document.html>`_ and parameter values in AWS Systems Manager to associate with this instance. To use this property, you must specify an IAM instance profile role for the instance. For more information, see `Create an IAM instance profile for Systems Manager <https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-configuring-access-role.html>`_ in the *AWS Systems Manager User Guide* .'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.SsmAssociationProperty"]]]], jsii.get(self, "ssmAssociations"))

    @ssm_associations.setter
    def ssm_associations(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.SsmAssociationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9a32550ddec52f1ba6a992df03aa6816270d379d0f512794e98b8d156f85a8c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ssmAssociations", value)

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the subnet to launch the instance into.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a62860fe29b6cb930a52f9295a28b9df24db9cb25b32334e42614ebcac2f918)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to add to the instance.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__03dfed2deae633759b409b545f5453f346f2bf97eabae0ec113f7acd20af0fd1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="tenancy")
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''The tenancy of the instance.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tenancy"))

    @tenancy.setter
    def tenancy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__04e99bf6ef2dde2a2e74e30ed9457bf21f79ada0defb8c84b9ebff315eb8dc35)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tenancy", value)

    @builtins.property
    @jsii.member(jsii_name="userData")
    def user_data(self) -> typing.Optional[builtins.str]:
        '''The parameters or scripts to store as user data.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "userData"))

    @user_data.setter
    def user_data(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8de558a59f9ec82f3fa87617c25ee9a0bbc302798e4bd35a548582053038e283)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "userData", value)

    @builtins.property
    @jsii.member(jsii_name="volumes")
    def volumes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.VolumeProperty"]]]]:
        '''The volumes to attach to the instance.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.VolumeProperty"]]]], jsii.get(self, "volumes"))

    @volumes.setter
    def volumes(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.VolumeProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e4c1329311f5d2e00f32bad89c015a6c70c9028f47f2c18bb6cfb8d46d5e16c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "volumes", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.AssociationParameterProperty",
        jsii_struct_bases=[],
        name_mapping={"key": "key", "value": "value"},
    )
    class AssociationParameterProperty:
        def __init__(
            self,
            *,
            key: builtins.str,
            value: typing.Sequence[builtins.str],
        ) -> None:
            '''Specifies input parameter values for an SSM document in AWS Systems Manager .

            ``AssociationParameter`` is a property of the `Amazon EC2 Instance SsmAssociation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ssmassociations.html>`_ property.

            :param key: The name of an input parameter that is in the associated SSM document.
            :param value: The value of an input parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-associationparameter.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                association_parameter_property = ec2.CfnInstance.AssociationParameterProperty(
                    key="key",
                    value=["value"]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ffbd0ef5f8b87f9c42c09b8038d3e08d70ac91ae4e60c9e24fd43b7a66e990f9)
                check_type(argname="argument key", value=key, expected_type=type_hints["key"])
                check_type(argname="argument value", value=value, expected_type=type_hints["value"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "key": key,
                "value": value,
            }

        @builtins.property
        def key(self) -> builtins.str:
            '''The name of an input parameter that is in the associated SSM document.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-associationparameter.html#cfn-ec2-instance-associationparameter-key
            '''
            result = self._values.get("key")
            assert result is not None, "Required property 'key' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def value(self) -> typing.List[builtins.str]:
            '''The value of an input parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-associationparameter.html#cfn-ec2-instance-associationparameter-value
            '''
            result = self._values.get("value")
            assert result is not None, "Required property 'value' is missing"
            return typing.cast(typing.List[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AssociationParameterProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.BlockDeviceMappingProperty",
        jsii_struct_bases=[],
        name_mapping={
            "device_name": "deviceName",
            "ebs": "ebs",
            "no_device": "noDevice",
            "virtual_name": "virtualName",
        },
    )
    class BlockDeviceMappingProperty:
        def __init__(
            self,
            *,
            device_name: builtins.str,
            ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.EbsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            no_device: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.NoDeviceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            virtual_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a block device mapping for an instance.

            You must specify exactly one of the following properties: ``VirtualName`` , ``Ebs`` , or ``NoDevice`` .

            ``BlockDeviceMapping`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.
            .. epigraph::

               After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :param device_name: The device name (for example, ``/dev/sdh`` or ``xvdh`` ). .. epigraph:: After the instance is running, this parameter is used to specify the device name of the block device mapping to update.
            :param ebs: Parameters used to automatically set up EBS volumes when the instance is launched. .. epigraph:: After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-no-interrupt>`_ .
            :param no_device: To omit the device from the block device mapping, specify an empty string. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param virtual_name: The virtual device name ( ``ephemeral`` N). The name must be in the form ``ephemeral`` *X* where *X* is a number starting from zero (0). For example, an instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume. NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect. *Constraints* : For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-blockdevicemapping.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                block_device_mapping_property = ec2.CfnInstance.BlockDeviceMappingProperty(
                    device_name="deviceName",
                
                    # the properties below are optional
                    ebs=ec2.CfnInstance.EbsProperty(
                        delete_on_termination=False,
                        encrypted=False,
                        iops=123,
                        kms_key_id="kmsKeyId",
                        snapshot_id="snapshotId",
                        volume_size=123,
                        volume_type="volumeType"
                    ),
                    no_device=ec2.CfnInstance.NoDeviceProperty(),
                    virtual_name="virtualName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f4a106aad6730f9ca5f686d6ef9aab93f20499e86fec16af163aef7ebf343991)
                check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
                check_type(argname="argument ebs", value=ebs, expected_type=type_hints["ebs"])
                check_type(argname="argument no_device", value=no_device, expected_type=type_hints["no_device"])
                check_type(argname="argument virtual_name", value=virtual_name, expected_type=type_hints["virtual_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "device_name": device_name,
            }
            if ebs is not None:
                self._values["ebs"] = ebs
            if no_device is not None:
                self._values["no_device"] = no_device
            if virtual_name is not None:
                self._values["virtual_name"] = virtual_name

        @builtins.property
        def device_name(self) -> builtins.str:
            '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).

            .. epigraph::

               After the instance is running, this parameter is used to specify the device name of the block device mapping to update.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-blockdevicemapping.html#cfn-ec2-instance-blockdevicemapping-devicename
            '''
            result = self._values.get("device_name")
            assert result is not None, "Required property 'device_name' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def ebs(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.EbsProperty"]]:
            '''Parameters used to automatically set up EBS volumes when the instance is launched.

            .. epigraph::

               After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-no-interrupt>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-blockdevicemapping.html#cfn-ec2-instance-blockdevicemapping-ebs
            '''
            result = self._values.get("ebs")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.EbsProperty"]], result)

        @builtins.property
        def no_device(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.NoDeviceProperty"]]:
            '''To omit the device from the block device mapping, specify an empty string.

            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-blockdevicemapping.html#cfn-ec2-instance-blockdevicemapping-nodevice
            '''
            result = self._values.get("no_device")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnInstance.NoDeviceProperty"]], result)

        @builtins.property
        def virtual_name(self) -> typing.Optional[builtins.str]:
            '''The virtual device name ( ``ephemeral`` N).

            The name must be in the form ``ephemeral`` *X* where *X* is a number starting from zero (0). For example, an instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.

            NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect.

            *Constraints* : For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.
            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-blockdevicemapping.html#cfn-ec2-instance-blockdevicemapping-virtualname
            '''
            result = self._values.get("virtual_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BlockDeviceMappingProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.CpuOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"core_count": "coreCount", "threads_per_core": "threadsPerCore"},
    )
    class CpuOptionsProperty:
        def __init__(
            self,
            *,
            core_count: typing.Optional[jsii.Number] = None,
            threads_per_core: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies the CPU options for the instance.

            When you specify CPU options, you must specify both the number of CPU cores and threads per core.

            Modifying the CPU options for an instance results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            For more information, see `Optimize CPU options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :param core_count: The number of CPU cores for the instance.
            :param threads_per_core: The number of threads per CPU core.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-cpuoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                cpu_options_property = ec2.CfnInstance.CpuOptionsProperty(
                    core_count=123,
                    threads_per_core=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__45379c3ed7954eb53d747ab4ead463612be3792fbeae21b5f509745cd20addea)
                check_type(argname="argument core_count", value=core_count, expected_type=type_hints["core_count"])
                check_type(argname="argument threads_per_core", value=threads_per_core, expected_type=type_hints["threads_per_core"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if core_count is not None:
                self._values["core_count"] = core_count
            if threads_per_core is not None:
                self._values["threads_per_core"] = threads_per_core

        @builtins.property
        def core_count(self) -> typing.Optional[jsii.Number]:
            '''The number of CPU cores for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-cpuoptions.html#cfn-ec2-instance-cpuoptions-corecount
            '''
            result = self._values.get("core_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def threads_per_core(self) -> typing.Optional[jsii.Number]:
            '''The number of threads per CPU core.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-cpuoptions.html#cfn-ec2-instance-cpuoptions-threadspercore
            '''
            result = self._values.get("threads_per_core")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CpuOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.CreditSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"cpu_credits": "cpuCredits"},
    )
    class CreditSpecificationProperty:
        def __init__(
            self,
            *,
            cpu_credits: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the credit option for CPU usage of a T instance.

            ``CreditSpecification`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ in the *Amazon EC2 User Guide* .

            :param cpu_credits: The credit option for CPU usage of the instance. Valid values: ``standard`` | ``unlimited`` T3 instances with ``host`` tenancy do not support the ``unlimited`` CPU credit option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-creditspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                credit_specification_property = ec2.CfnInstance.CreditSpecificationProperty(
                    cpu_credits="cpuCredits"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c7ae201613ad2718c445d39a0ac680b5d91a24d023530b4f9f672b6bbd84e99b)
                check_type(argname="argument cpu_credits", value=cpu_credits, expected_type=type_hints["cpu_credits"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if cpu_credits is not None:
                self._values["cpu_credits"] = cpu_credits

        @builtins.property
        def cpu_credits(self) -> typing.Optional[builtins.str]:
            '''The credit option for CPU usage of the instance.

            Valid values: ``standard`` | ``unlimited``

            T3 instances with ``host`` tenancy do not support the ``unlimited`` CPU credit option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-creditspecification.html#cfn-ec2-instance-creditspecification-cpucredits
            '''
            result = self._values.get("cpu_credits")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CreditSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.EbsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "delete_on_termination": "deleteOnTermination",
            "encrypted": "encrypted",
            "iops": "iops",
            "kms_key_id": "kmsKeyId",
            "snapshot_id": "snapshotId",
            "volume_size": "volumeSize",
            "volume_type": "volumeType",
        },
    )
    class EbsProperty:
        def __init__(
            self,
            *,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            iops: typing.Optional[jsii.Number] = None,
            kms_key_id: typing.Optional[builtins.str] = None,
            snapshot_id: typing.Optional[builtins.str] = None,
            volume_size: typing.Optional[jsii.Number] = None,
            volume_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a block device for an EBS volume.

            ``Ebs`` is a property of the `Amazon EC2 BlockDeviceMapping <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-blockdev-mapping.html>`_ property.
            .. epigraph::

               After the instance is running, you can modify only the ``DeleteOnTermination`` parameters for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :param delete_on_termination: Indicates whether the EBS volume is deleted on instance termination. For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .
            :param encrypted: Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the *Amazon Elastic Compute Cloud User Guide* . Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ . .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000-16,000 IOPS - ``io1`` : 100-64,000 IOPS - ``io2`` : 100-64,000 IOPS For ``io1`` and ``io2`` volumes, we guarantee 64,000 IOPS only for `Instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . Other instance families guarantee performance up to 32,000 IOPS. This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS. This parameter is not supported for ``gp2`` , ``st1`` , ``sc1`` , or ``standard`` volumes. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param kms_key_id: The identifier of the AWS KMS key to use for Amazon EBS encryption. If ``KmsKeyId`` is specified, the encrypted state must be ``true`` . If the encrypted state is ``true`` but you do not specify ``KmsKeyId`` , your KMS key for EBS is used. You can specify the KMS key using any of the following: - Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab. - Key alias. For example, alias/ExampleAlias. - Key ARN. For example, arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab. - Alias ARN. For example, arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param snapshot_id: The ID of the snapshot. If you specify both ``SnapshotId`` and ``VolumeSize`` , ``VolumeSize`` must be equal or greater than the size of the snapshot. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param volume_size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size. The following are the supported volumes sizes for each volume type: - ``gp2`` and ``gp3`` :1-16,384 - ``io1`` and ``io2`` : 4-16,384 - ``st1`` and ``sc1`` : 125-16,384 - ``standard`` : 1-1,024 .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
            :param volume_type: The volume type. For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon EC2 User Guide* . If the volume type is ``io1`` or ``io2`` , you must specify the IOPS that the volume supports. .. epigraph:: After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ebs_property = ec2.CfnInstance.EbsProperty(
                    delete_on_termination=False,
                    encrypted=False,
                    iops=123,
                    kms_key_id="kmsKeyId",
                    snapshot_id="snapshotId",
                    volume_size=123,
                    volume_type="volumeType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__4c09eac02d54a6564087da67099588cd163dab15cf7c17800691ac57e91afadc)
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
                check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
                check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
                check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
                check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
                check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if encrypted is not None:
                self._values["encrypted"] = encrypted
            if iops is not None:
                self._values["iops"] = iops
            if kms_key_id is not None:
                self._values["kms_key_id"] = kms_key_id
            if snapshot_id is not None:
                self._values["snapshot_id"] = snapshot_id
            if volume_size is not None:
                self._values["volume_size"] = volume_size
            if volume_type is not None:
                self._values["volume_type"] = volume_type

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the EBS volume is deleted on instance termination.

            For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def encrypted(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the volume should be encrypted.

            The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ .
            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-encrypted
            '''
            result = self._values.get("encrypted")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def iops(self) -> typing.Optional[jsii.Number]:
            '''The number of I/O operations per second (IOPS).

            For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.

            The following are the supported values for each volume type:

            - ``gp3`` : 3,000-16,000 IOPS
            - ``io1`` : 100-64,000 IOPS
            - ``io2`` : 100-64,000 IOPS

            For ``io1`` and ``io2`` volumes, we guarantee 64,000 IOPS only for `Instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . Other instance families guarantee performance up to 32,000 IOPS.

            This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS. This parameter is not supported for ``gp2`` , ``st1`` , ``sc1`` , or ``standard`` volumes.
            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-iops
            '''
            result = self._values.get("iops")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def kms_key_id(self) -> typing.Optional[builtins.str]:
            '''The identifier of the AWS KMS key to use for Amazon EBS encryption.

            If ``KmsKeyId`` is specified, the encrypted state must be ``true`` . If the encrypted state is ``true`` but you do not specify ``KmsKeyId`` , your KMS key for EBS is used.

            You can specify the KMS key using any of the following:

            - Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab.
            - Key alias. For example, alias/ExampleAlias.
            - Key ARN. For example, arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.
            - Alias ARN. For example, arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias.

            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-kmskeyid
            '''
            result = self._values.get("kms_key_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def snapshot_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the snapshot.

            If you specify both ``SnapshotId`` and ``VolumeSize`` , ``VolumeSize`` must be equal or greater than the size of the snapshot.
            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-snapshotid
            '''
            result = self._values.get("snapshot_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def volume_size(self) -> typing.Optional[jsii.Number]:
            '''The size of the volume, in GiBs.

            You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size.

            The following are the supported volumes sizes for each volume type:

            - ``gp2`` and ``gp3`` :1-16,384
            - ``io1`` and ``io2`` : 4-16,384
            - ``st1`` and ``sc1`` : 125-16,384
            - ``standard`` : 1-1,024

            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-volumesize
            '''
            result = self._values.get("volume_size")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def volume_type(self) -> typing.Optional[builtins.str]:
            '''The volume type.

            For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon EC2 User Guide* . If the volume type is ``io1`` or ``io2`` , you must specify the IOPS that the volume supports.
            .. epigraph::

               After the instance is running, modifying this parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ebs.html#cfn-ec2-instance-ebs-volumetype
            '''
            result = self._values.get("volume_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EbsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.ElasticGpuSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"type": "type"},
    )
    class ElasticGpuSpecificationProperty:
        def __init__(self, *, type: builtins.str) -> None:
            '''.. epigraph::

   Amazon Elastic Graphics reached end of life on January 8, 2024.

            For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.

            Specifies the type of Elastic GPU. An Elastic GPU is a GPU resource that you can attach to your Amazon EC2 instance to accelerate the graphics performance of your applications. For more information, see `Amazon EC2 Elastic GPUs <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html>`_ in the *Amazon EC2 User Guide for Windows Instances* .

            ``ElasticGpuSpecification`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param type: The type of Elastic Graphics accelerator. For more information about the values to specify for ``Type`` , see `Elastic Graphics Basics <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html#elastic-graphics-basics>`_ , specifically the Elastic Graphics accelerator column, in the *Amazon Elastic Compute Cloud User Guide for Windows Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-elasticgpuspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                elastic_gpu_specification_property = ec2.CfnInstance.ElasticGpuSpecificationProperty(
                    type="type"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__2006caad7133f0ab7c61e8b156da32a8d1454211df92dd829182336ffa0ebb4f)
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "type": type,
            }

        @builtins.property
        def type(self) -> builtins.str:
            '''The type of Elastic Graphics accelerator.

            For more information about the values to specify for ``Type`` , see `Elastic Graphics Basics <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html#elastic-graphics-basics>`_ , specifically the Elastic Graphics accelerator column, in the *Amazon Elastic Compute Cloud User Guide for Windows Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-elasticgpuspecification.html#cfn-ec2-instance-elasticgpuspecification-type
            '''
            result = self._values.get("type")
            assert result is not None, "Required property 'type' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ElasticGpuSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.ElasticInferenceAcceleratorProperty",
        jsii_struct_bases=[],
        name_mapping={"type": "type", "count": "count"},
    )
    class ElasticInferenceAcceleratorProperty:
        def __init__(
            self,
            *,
            type: builtins.str,
            count: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies the Elastic Inference Accelerator for the instance.

            ``ElasticInferenceAccelerator`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param type: The type of elastic inference accelerator. The possible values are ``eia1.medium`` , ``eia1.large`` , ``eia1.xlarge`` , ``eia2.medium`` , ``eia2.large`` , and ``eia2.xlarge`` .
            :param count: The number of elastic inference accelerators to attach to the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-elasticinferenceaccelerator.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                elastic_inference_accelerator_property = ec2.CfnInstance.ElasticInferenceAcceleratorProperty(
                    type="type",
                
                    # the properties below are optional
                    count=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9b0fb3dd7e11b3d77e5e684588da3e531072d536c01a1f2f8089cb89ffd0d393)
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
                check_type(argname="argument count", value=count, expected_type=type_hints["count"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "type": type,
            }
            if count is not None:
                self._values["count"] = count

        @builtins.property
        def type(self) -> builtins.str:
            '''The type of elastic inference accelerator.

            The possible values are ``eia1.medium`` , ``eia1.large`` , ``eia1.xlarge`` , ``eia2.medium`` , ``eia2.large`` , and ``eia2.xlarge`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-elasticinferenceaccelerator.html#cfn-ec2-instance-elasticinferenceaccelerator-type
            '''
            result = self._values.get("type")
            assert result is not None, "Required property 'type' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def count(self) -> typing.Optional[jsii.Number]:
            '''The number of elastic inference accelerators to attach to the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-elasticinferenceaccelerator.html#cfn-ec2-instance-elasticinferenceaccelerator-count
            '''
            result = self._values.get("count")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ElasticInferenceAcceleratorProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.EnclaveOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled"},
    )
    class EnclaveOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Indicates whether the instance is enabled for AWS Nitro Enclaves.

            :param enabled: If this parameter is set to ``true`` , the instance is enabled for AWS Nitro Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-enclaveoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                enclave_options_property = ec2.CfnInstance.EnclaveOptionsProperty(
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__a5c9ea6a0fe6571a95aa17f5c0b6f90e2695fa23c1a38965ff092c2938757847)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''If this parameter is set to ``true`` , the instance is enabled for AWS Nitro Enclaves;

            otherwise, it is not enabled for AWS Nitro Enclaves.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-enclaveoptions.html#cfn-ec2-instance-enclaveoptions-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EnclaveOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.HibernationOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"configured": "configured"},
    )
    class HibernationOptionsProperty:
        def __init__(
            self,
            *,
            configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Specifies the hibernation options for the instance.

            ``HibernationOptions`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param configured: Set to ``true`` to enable your instance for hibernation. For Spot Instances, if you set ``Configured`` to ``true`` , either omit the ``InstanceInterruptionBehavior`` parameter (for ```SpotMarketOptions`` <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotMarketOptions.html>`_ ), or set it to ``hibernate`` . When ``Configured`` is true: - If you omit ``InstanceInterruptionBehavior`` , it defaults to ``hibernate`` . - If you set ``InstanceInterruptionBehavior`` to a value other than ``hibernate`` , you'll get an error. Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-hibernationoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                hibernation_options_property = ec2.CfnInstance.HibernationOptionsProperty(
                    configured=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__dae862a3b461d8dee633cb41e9b02aa56bd4ec0b297ae67d92791d54f8c77762)
                check_type(argname="argument configured", value=configured, expected_type=type_hints["configured"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if configured is not None:
                self._values["configured"] = configured

        @builtins.property
        def configured(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Set to ``true`` to enable your instance for hibernation.

            For Spot Instances, if you set ``Configured`` to ``true`` , either omit the ``InstanceInterruptionBehavior`` parameter (for ```SpotMarketOptions`` <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotMarketOptions.html>`_ ), or set it to ``hibernate`` . When ``Configured`` is true:

            - If you omit ``InstanceInterruptionBehavior`` , it defaults to ``hibernate`` .
            - If you set ``InstanceInterruptionBehavior`` to a value other than ``hibernate`` , you'll get an error.

            Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-hibernationoptions.html#cfn-ec2-instance-hibernationoptions-configured
            '''
            result = self._values.get("configured")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "HibernationOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.InstanceIpv6AddressProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_address": "ipv6Address"},
    )
    class InstanceIpv6AddressProperty:
        def __init__(self, *, ipv6_address: builtins.str) -> None:
            '''Specifies the IPv6 address for the instance.

            ``InstanceIpv6Address`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param ipv6_address: The IPv6 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-instanceipv6address.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_ipv6_address_property = ec2.CfnInstance.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__330892e6831efeed9c5add9ac36c4eae4adff9e6648b88f0677f7d3f9047754c)
                check_type(argname="argument ipv6_address", value=ipv6_address, expected_type=type_hints["ipv6_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ipv6_address": ipv6_address,
            }

        @builtins.property
        def ipv6_address(self) -> builtins.str:
            '''The IPv6 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-instanceipv6address.html#cfn-ec2-instance-instanceipv6address-ipv6address
            '''
            result = self._values.get("ipv6_address")
            assert result is not None, "Required property 'ipv6_address' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceIpv6AddressProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.LaunchTemplateSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "version": "version",
            "launch_template_id": "launchTemplateId",
            "launch_template_name": "launchTemplateName",
        },
    )
    class LaunchTemplateSpecificationProperty:
        def __init__(
            self,
            *,
            version: builtins.str,
            launch_template_id: typing.Optional[builtins.str] = None,
            launch_template_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a launch template to use when launching an Amazon EC2 instance.

            You must specify the following:

            - The ID or the name of the launch template, but not both.
            - The version of the launch template.

            ``LaunchTemplateSpecification`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            For information about creating a launch template, see `AWS::EC2::LaunchTemplate <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html>`_ and `Create a launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ in the *Amazon EC2 User Guide* .

            For examples of launch templates, see `Examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples>`_ .

            :param version: The version number of the launch template. Specifying ``$Latest`` or ``$Default`` for the template version number is not supported. However, you can specify ``LatestVersionNumber`` or ``DefaultVersionNumber`` using the ``Fn::GetAtt`` intrinsic function. For more information, see `Fn::GetAtt <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate-return-values-fn--getatt>`_ .
            :param launch_template_id: The ID of the launch template. You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.
            :param launch_template_name: The name of the launch template. You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-launchtemplatespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_specification_property = ec2.CfnInstance.LaunchTemplateSpecificationProperty(
                    version="version",
                
                    # the properties below are optional
                    launch_template_id="launchTemplateId",
                    launch_template_name="launchTemplateName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__aaee6a84463cd94666c3a6c5dc8639cb47853fcdf7ddc4f965316f0260f6985e)
                check_type(argname="argument version", value=version, expected_type=type_hints["version"])
                check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
                check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "version": version,
            }
            if launch_template_id is not None:
                self._values["launch_template_id"] = launch_template_id
            if launch_template_name is not None:
                self._values["launch_template_name"] = launch_template_name

        @builtins.property
        def version(self) -> builtins.str:
            '''The version number of the launch template.

            Specifying ``$Latest`` or ``$Default`` for the template version number is not supported. However, you can specify ``LatestVersionNumber`` or ``DefaultVersionNumber`` using the ``Fn::GetAtt`` intrinsic function. For more information, see `Fn::GetAtt <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate-return-values-fn--getatt>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-launchtemplatespecification.html#cfn-ec2-instance-launchtemplatespecification-version
            '''
            result = self._values.get("version")
            assert result is not None, "Required property 'version' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def launch_template_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the launch template.

            You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-launchtemplatespecification.html#cfn-ec2-instance-launchtemplatespecification-launchtemplateid
            '''
            result = self._values.get("launch_template_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def launch_template_name(self) -> typing.Optional[builtins.str]:
            '''The name of the launch template.

            You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-launchtemplatespecification.html#cfn-ec2-instance-launchtemplatespecification-launchtemplatename
            '''
            result = self._values.get("launch_template_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.LicenseSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"license_configuration_arn": "licenseConfigurationArn"},
    )
    class LicenseSpecificationProperty:
        def __init__(self, *, license_configuration_arn: builtins.str) -> None:
            '''Specifies the license configuration to use.

            ``LicenseSpecification`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param license_configuration_arn: The Amazon Resource Name (ARN) of the license configuration.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-licensespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                license_specification_property = ec2.CfnInstance.LicenseSpecificationProperty(
                    license_configuration_arn="licenseConfigurationArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d052358cb33e29932cee94076b50021e871c21fc3250e7670a7f774376eceeda)
                check_type(argname="argument license_configuration_arn", value=license_configuration_arn, expected_type=type_hints["license_configuration_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "license_configuration_arn": license_configuration_arn,
            }

        @builtins.property
        def license_configuration_arn(self) -> builtins.str:
            '''The Amazon Resource Name (ARN) of the license configuration.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-licensespecification.html#cfn-ec2-instance-licensespecification-licenseconfigurationarn
            '''
            result = self._values.get("license_configuration_arn")
            assert result is not None, "Required property 'license_configuration_arn' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LicenseSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.NetworkInterfaceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "device_index": "deviceIndex",
            "associate_carrier_ip_address": "associateCarrierIpAddress",
            "associate_public_ip_address": "associatePublicIpAddress",
            "delete_on_termination": "deleteOnTermination",
            "description": "description",
            "group_set": "groupSet",
            "ipv6_address_count": "ipv6AddressCount",
            "ipv6_addresses": "ipv6Addresses",
            "network_interface_id": "networkInterfaceId",
            "private_ip_address": "privateIpAddress",
            "private_ip_addresses": "privateIpAddresses",
            "secondary_private_ip_address_count": "secondaryPrivateIpAddressCount",
            "subnet_id": "subnetId",
        },
    )
    class NetworkInterfaceProperty:
        def __init__(
            self,
            *,
            device_index: builtins.str,
            associate_carrier_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            description: typing.Optional[builtins.str] = None,
            group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
            ipv6_address_count: typing.Optional[jsii.Number] = None,
            ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.InstanceIpv6AddressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            network_interface_id: typing.Optional[builtins.str] = None,
            private_ip_address: typing.Optional[builtins.str] = None,
            private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.PrivateIpAddressSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
            subnet_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a network interface that is to be attached to an instance.

            You can create a network interface when launching an instance. For an example, see the `AWS::EC2::Instance examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html#aws-properties-ec2-instance--examples--Automatically_assign_a_public_IP_address>`_ .

            Alternatively, you can attach an existing network interface when launching an instance. For an example, see the `AWS::EC2:NetworkInterface examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#aws-resource-ec2-networkinterface--examples>`_ .

            :param device_index: The position of the network interface in the attachment order. A primary network interface has a device index of 0. If you create a network interface when launching an instance, you must specify the device index.
            :param associate_carrier_ip_address: Indicates whether to assign a carrier IP address to the network interface. You can only assign a carrier IP address to a network interface that is in a subnet in a Wavelength Zone. For more information about carrier IP addresses, see `Carrier IP address <https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#provider-owned-ip>`_ in the *AWS Wavelength Developer Guide* .
            :param associate_public_ip_address: Indicates whether to assign a public IPv4 address to an instance. Applies only if creating a network interface when launching an instance. The network interface must be the primary network interface. If launching into a default subnet, the default value is ``true`` . AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .
            :param delete_on_termination: Indicates whether the network interface is deleted when the instance is terminated. Applies only if creating a network interface when launching an instance.
            :param description: The description of the network interface. Applies only if creating a network interface when launching an instance.
            :param group_set: The IDs of the security groups for the network interface. Applies only if creating a network interface when launching an instance.
            :param ipv6_address_count: A number of IPv6 addresses to assign to the network interface. Amazon EC2 chooses the IPv6 addresses from the range of the subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch.
            :param ipv6_addresses: The IPv6 addresses to assign to the network interface. You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch.
            :param network_interface_id: The ID of the network interface, when attaching an existing network interface.
            :param private_ip_address: The private IPv4 address of the network interface. Applies only if creating a network interface when launching an instance.
            :param private_ip_addresses: One or more private IPv4 addresses to assign to the network interface. Only one private IPv4 address can be designated as primary.
            :param secondary_private_ip_address_count: The number of secondary private IPv4 addresses. You can't specify this option and specify more than one private IP address using the private IP addresses option.
            :param subnet_id: The ID of the subnet associated with the network interface. Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_property = ec2.CfnInstance.NetworkInterfaceProperty(
                    device_index="deviceIndex",
                
                    # the properties below are optional
                    associate_carrier_ip_address=False,
                    associate_public_ip_address=False,
                    delete_on_termination=False,
                    description="description",
                    group_set=["groupSet"],
                    ipv6_address_count=123,
                    ipv6_addresses=[ec2.CfnInstance.InstanceIpv6AddressProperty(
                        ipv6_address="ipv6Address"
                    )],
                    network_interface_id="networkInterfaceId",
                    private_ip_address="privateIpAddress",
                    private_ip_addresses=[ec2.CfnInstance.PrivateIpAddressSpecificationProperty(
                        primary=False,
                        private_ip_address="privateIpAddress"
                    )],
                    secondary_private_ip_address_count=123,
                    subnet_id="subnetId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__34d8c3e0456d2764eb1c3d4b68e63d75d3e51811fe46a5cc1a3cd7a841079228)
                check_type(argname="argument device_index", value=device_index, expected_type=type_hints["device_index"])
                check_type(argname="argument associate_carrier_ip_address", value=associate_carrier_ip_address, expected_type=type_hints["associate_carrier_ip_address"])
                check_type(argname="argument associate_public_ip_address", value=associate_public_ip_address, expected_type=type_hints["associate_public_ip_address"])
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument group_set", value=group_set, expected_type=type_hints["group_set"])
                check_type(argname="argument ipv6_address_count", value=ipv6_address_count, expected_type=type_hints["ipv6_address_count"])
                check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
                check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
                check_type(argname="argument private_ip_addresses", value=private_ip_addresses, expected_type=type_hints["private_ip_addresses"])
                check_type(argname="argument secondary_private_ip_address_count", value=secondary_private_ip_address_count, expected_type=type_hints["secondary_private_ip_address_count"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "device_index": device_index,
            }
            if associate_carrier_ip_address is not None:
                self._values["associate_carrier_ip_address"] = associate_carrier_ip_address
            if associate_public_ip_address is not None:
                self._values["associate_public_ip_address"] = associate_public_ip_address
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if description is not None:
                self._values["description"] = description
            if group_set is not None:
                self._values["group_set"] = group_set
            if ipv6_address_count is not None:
                self._values["ipv6_address_count"] = ipv6_address_count
            if ipv6_addresses is not None:
                self._values["ipv6_addresses"] = ipv6_addresses
            if network_interface_id is not None:
                self._values["network_interface_id"] = network_interface_id
            if private_ip_address is not None:
                self._values["private_ip_address"] = private_ip_address
            if private_ip_addresses is not None:
                self._values["private_ip_addresses"] = private_ip_addresses
            if secondary_private_ip_address_count is not None:
                self._values["secondary_private_ip_address_count"] = secondary_private_ip_address_count
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id

        @builtins.property
        def device_index(self) -> builtins.str:
            '''The position of the network interface in the attachment order.

            A primary network interface has a device index of 0.

            If you create a network interface when launching an instance, you must specify the device index.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-deviceindex
            '''
            result = self._values.get("device_index")
            assert result is not None, "Required property 'device_index' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def associate_carrier_ip_address(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to assign a carrier IP address to the network interface.

            You can only assign a carrier IP address to a network interface that is in a subnet in a Wavelength Zone. For more information about carrier IP addresses, see `Carrier IP address <https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#provider-owned-ip>`_ in the *AWS Wavelength Developer Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-associatecarrieripaddress
            '''
            result = self._values.get("associate_carrier_ip_address")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def associate_public_ip_address(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to assign a public IPv4 address to an instance.

            Applies only if creating a network interface when launching an instance. The network interface must be the primary network interface. If launching into a default subnet, the default value is ``true`` .

            AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-associatepublicipaddress
            '''
            result = self._values.get("associate_public_ip_address")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the network interface is deleted when the instance is terminated.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''The description of the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def group_set(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IDs of the security groups for the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-groupset
            '''
            result = self._values.get("group_set")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
            '''A number of IPv6 addresses to assign to the network interface.

            Amazon EC2 chooses the IPv6 addresses from the range of the subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-ipv6addresscount
            '''
            result = self._values.get("ipv6_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ipv6_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.InstanceIpv6AddressProperty"]]]]:
            '''The IPv6 addresses to assign to the network interface.

            You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-ipv6addresses
            '''
            result = self._values.get("ipv6_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.InstanceIpv6AddressProperty"]]]], result)

        @builtins.property
        def network_interface_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the network interface, when attaching an existing network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-networkinterfaceid
            '''
            result = self._values.get("network_interface_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def private_ip_address(self) -> typing.Optional[builtins.str]:
            '''The private IPv4 address of the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def private_ip_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.PrivateIpAddressSpecificationProperty"]]]]:
            '''One or more private IPv4 addresses to assign to the network interface.

            Only one private IPv4 address can be designated as primary.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-privateipaddresses
            '''
            result = self._values.get("private_ip_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.PrivateIpAddressSpecificationProperty"]]]], result)

        @builtins.property
        def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
            '''The number of secondary private IPv4 addresses.

            You can't specify this option and specify more than one private IP address using the private IP addresses option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-secondaryprivateipaddresscount
            '''
            result = self._values.get("secondary_private_ip_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the subnet associated with the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-networkinterface.html#cfn-ec2-instance-networkinterface-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.NoDeviceProperty",
        jsii_struct_bases=[],
        name_mapping={},
    )
    class NoDeviceProperty:
        def __init__(self) -> None:
            '''
            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-nodevice.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                no_device_property = ec2.CfnInstance.NoDeviceProperty()
            '''
            self._values: typing.Dict[builtins.str, typing.Any] = {}

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NoDeviceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.PrivateDnsNameOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "enable_resource_name_dns_aaaa_record": "enableResourceNameDnsAaaaRecord",
            "enable_resource_name_dns_a_record": "enableResourceNameDnsARecord",
            "hostname_type": "hostnameType",
        },
    )
    class PrivateDnsNameOptionsProperty:
        def __init__(
            self,
            *,
            enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            hostname_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The type of hostnames to assign to instances in the subnet at launch.

            For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :param enable_resource_name_dns_aaaa_record: Indicates whether to respond to DNS queries for instance hostnames with DNS AAAA records. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param enable_resource_name_dns_a_record: Indicates whether to respond to DNS queries for instance hostnames with DNS A records. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param hostname_type: The type of hostnames to assign to instances in the subnet at launch. For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privatednsnameoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_dns_name_options_property = ec2.CfnInstance.PrivateDnsNameOptionsProperty(
                    enable_resource_name_dns_aaaa_record=False,
                    enable_resource_name_dns_aRecord=False,
                    hostname_type="hostnameType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__5dfb67cedae0be1e7c4648da61cd29a55b6dc2ec2d3061d52059a4f784441ee9)
                check_type(argname="argument enable_resource_name_dns_aaaa_record", value=enable_resource_name_dns_aaaa_record, expected_type=type_hints["enable_resource_name_dns_aaaa_record"])
                check_type(argname="argument enable_resource_name_dns_a_record", value=enable_resource_name_dns_a_record, expected_type=type_hints["enable_resource_name_dns_a_record"])
                check_type(argname="argument hostname_type", value=hostname_type, expected_type=type_hints["hostname_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enable_resource_name_dns_aaaa_record is not None:
                self._values["enable_resource_name_dns_aaaa_record"] = enable_resource_name_dns_aaaa_record
            if enable_resource_name_dns_a_record is not None:
                self._values["enable_resource_name_dns_a_record"] = enable_resource_name_dns_a_record
            if hostname_type is not None:
                self._values["hostname_type"] = hostname_type

        @builtins.property
        def enable_resource_name_dns_aaaa_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostnames with DNS AAAA records.

            For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privatednsnameoptions.html#cfn-ec2-instance-privatednsnameoptions-enableresourcenamednsaaaarecord
            '''
            result = self._values.get("enable_resource_name_dns_aaaa_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def enable_resource_name_dns_a_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostnames with DNS A records.

            For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privatednsnameoptions.html#cfn-ec2-instance-privatednsnameoptions-enableresourcenamednsarecord
            '''
            result = self._values.get("enable_resource_name_dns_a_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def hostname_type(self) -> typing.Optional[builtins.str]:
            '''The type of hostnames to assign to instances in the subnet at launch.

            For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privatednsnameoptions.html#cfn-ec2-instance-privatednsnameoptions-hostnametype
            '''
            result = self._values.get("hostname_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateDnsNameOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.PrivateIpAddressSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"primary": "primary", "private_ip_address": "privateIpAddress"},
    )
    class PrivateIpAddressSpecificationProperty:
        def __init__(
            self,
            *,
            primary: typing.Union[builtins.bool, _IResolvable_da3f097b],
            private_ip_address: builtins.str,
        ) -> None:
            '''Specifies a secondary private IPv4 address for a network interface.

            :param primary: Indicates whether the private IPv4 address is the primary private IPv4 address. Only one IPv4 address can be designated as primary.
            :param private_ip_address: The private IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privateipaddressspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_ip_address_specification_property = ec2.CfnInstance.PrivateIpAddressSpecificationProperty(
                    primary=False,
                    private_ip_address="privateIpAddress"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f4ccfd0fce39abb37ef8133498166c476cc4ec24520f550b1ad8e4ff16a98de5)
                check_type(argname="argument primary", value=primary, expected_type=type_hints["primary"])
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "primary": primary,
                "private_ip_address": private_ip_address,
            }

        @builtins.property
        def primary(self) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''Indicates whether the private IPv4 address is the primary private IPv4 address.

            Only one IPv4 address can be designated as primary.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privateipaddressspecification.html#cfn-ec2-instance-privateipaddressspecification-primary
            '''
            result = self._values.get("primary")
            assert result is not None, "Required property 'primary' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def private_ip_address(self) -> builtins.str:
            '''The private IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-privateipaddressspecification.html#cfn-ec2-instance-privateipaddressspecification-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            assert result is not None, "Required property 'private_ip_address' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateIpAddressSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.SsmAssociationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "document_name": "documentName",
            "association_parameters": "associationParameters",
        },
    )
    class SsmAssociationProperty:
        def __init__(
            self,
            *,
            document_name: builtins.str,
            association_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnInstance.AssociationParameterProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ) -> None:
            '''Specifies the SSM document and parameter values in AWS Systems Manager to associate with an instance.

            ``SsmAssociations`` is a property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param document_name: The name of an SSM document to associate with the instance.
            :param association_parameters: The input parameter values to use with the associated SSM document.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ssmassociation.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ssm_association_property = ec2.CfnInstance.SsmAssociationProperty(
                    document_name="documentName",
                
                    # the properties below are optional
                    association_parameters=[ec2.CfnInstance.AssociationParameterProperty(
                        key="key",
                        value=["value"]
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__3246e3302ff8df6b195439adc5ead244f95f45eca29b97351de498153f5e99c9)
                check_type(argname="argument document_name", value=document_name, expected_type=type_hints["document_name"])
                check_type(argname="argument association_parameters", value=association_parameters, expected_type=type_hints["association_parameters"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "document_name": document_name,
            }
            if association_parameters is not None:
                self._values["association_parameters"] = association_parameters

        @builtins.property
        def document_name(self) -> builtins.str:
            '''The name of an SSM document to associate with the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ssmassociation.html#cfn-ec2-instance-ssmassociation-documentname
            '''
            result = self._values.get("document_name")
            assert result is not None, "Required property 'document_name' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def association_parameters(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.AssociationParameterProperty"]]]]:
            '''The input parameter values to use with the associated SSM document.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-ssmassociation.html#cfn-ec2-instance-ssmassociation-associationparameters
            '''
            result = self._values.get("association_parameters")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnInstance.AssociationParameterProperty"]]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SsmAssociationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.VolumeProperty",
        jsii_struct_bases=[],
        name_mapping={"device": "device", "volume_id": "volumeId"},
    )
    class VolumeProperty:
        def __init__(self, *, device: builtins.str, volume_id: builtins.str) -> None:
            '''Specifies a volume to attach to an instance.

            ``Volume`` is an embedded property of the `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource.

            :param device: The device name (for example, ``/dev/sdh`` or ``xvdh`` ).
            :param volume_id: The ID of the EBS volume. The volume and instance must be within the same Availability Zone.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-volume.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                volume_property = ec2.CfnInstance.VolumeProperty(
                    device="device",
                    volume_id="volumeId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b979ff4b2e7bc79429f0409f1fb60a5125a9cda71770a0324082ebc0a6c50756)
                check_type(argname="argument device", value=device, expected_type=type_hints["device"])
                check_type(argname="argument volume_id", value=volume_id, expected_type=type_hints["volume_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "device": device,
                "volume_id": volume_id,
            }

        @builtins.property
        def device(self) -> builtins.str:
            '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-volume.html#cfn-ec2-instance-volume-device
            '''
            result = self._values.get("device")
            assert result is not None, "Required property 'device' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def volume_id(self) -> builtins.str:
            '''The ID of the EBS volume.

            The volume and instance must be within the same Availability Zone.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-volume.html#cfn-ec2-instance-volume-volumeid
            '''
            result = self._values.get("volume_id")
            assert result is not None, "Required property 'volume_id' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VolumeProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnInstanceConnectEndpoint(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnInstanceConnectEndpoint",
):
    '''Creates an EC2 Instance Connect Endpoint.

    An EC2 Instance Connect Endpoint allows you to connect to an instance, without requiring the instance to have a public IPv4 address. For more information, see `Connect to your instances without requiring a public IPv4 address using EC2 Instance Connect Endpoint <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect-Endpoint.html>`_ in the *Amazon EC2 User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html
    :cloudformationResource: AWS::EC2::InstanceConnectEndpoint
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_instance_connect_endpoint = ec2.CfnInstanceConnectEndpoint(self, "MyCfnInstanceConnectEndpoint",
            subnet_id="subnetId",
        
            # the properties below are optional
            client_token="clientToken",
            preserve_client_ip=False,
            security_group_ids=["securityGroupIds"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        client_token: typing.Optional[builtins.str] = None,
        preserve_client_ip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_id: The ID of the subnet in which to create the EC2 Instance Connect Endpoint.
        :param client_token: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        :param preserve_client_ip: Indicates whether your client's IP address is preserved as the source. The value is ``true`` or ``false`` . - If ``true`` , your client's IP address is used when you connect to a resource. - If ``false`` , the elastic network interface IP address is used when you connect to a resource. Default: ``true``
        :param security_group_ids: One or more security groups to associate with the endpoint. If you don't specify a security group, the default security group for your VPC will be associated with the endpoint.
        :param tags: The tags to apply to the EC2 Instance Connect Endpoint during creation.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5dd25848f0ceb23edd764d8f4a076cf8f9d22793b6ca99db922a9c410f58ba1f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnInstanceConnectEndpointProps(
            subnet_id=subnet_id,
            client_token=client_token,
            preserve_client_ip=preserve_client_ip,
            security_group_ids=security_group_ids,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5891536cec39a3051ee1e1e6cad74074ab2e104448cf33448a891defadf16b6e)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08af6017181d75f497ef7453c702f6e6ac3f87faf252f7dae4c9797af2382847)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the EC2 Instance Connect Endpoint.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet in which to create the EC2 Instance Connect Endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__18fe6754ba2f44060c4a7a2127a488b7e626c5c1761f524fdb756846a1b48e44)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="clientToken")
    def client_token(self) -> typing.Optional[builtins.str]:
        '''Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "clientToken"))

    @client_token.setter
    def client_token(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a075309e51f465140660c0455acd101077c2364e286033707a8d1e11f4cc3a6a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "clientToken", value)

    @builtins.property
    @jsii.member(jsii_name="preserveClientIp")
    def preserve_client_ip(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether your client's IP address is preserved as the source.

        The value is ``true`` or ``false`` .
        '''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "preserveClientIp"))

    @preserve_client_ip.setter
    def preserve_client_ip(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a3c9af51a15924a206fae71c0b2615bf7be3e42b8bb7722c9e794e13a40973a7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "preserveClientIp", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIds")
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''One or more security groups to associate with the endpoint.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroupIds"))

    @security_group_ids.setter
    def security_group_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9a795e386e76f7e1445d90e3d1e800e540f41237f0e797a5e2058cb7b78553e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIds", value)

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the EC2 Instance Connect Endpoint during creation.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tags"))

    @tags.setter
    def tags(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3dd5921daaa37553fc9b30d074bd3ef6cfc6e9a796db9530140935d020cd87ae)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tags", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnInstanceConnectEndpointProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "client_token": "clientToken",
        "preserve_client_ip": "preserveClientIp",
        "security_group_ids": "securityGroupIds",
        "tags": "tags",
    },
)
class CfnInstanceConnectEndpointProps:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        client_token: typing.Optional[builtins.str] = None,
        preserve_client_ip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnInstanceConnectEndpoint``.

        :param subnet_id: The ID of the subnet in which to create the EC2 Instance Connect Endpoint.
        :param client_token: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        :param preserve_client_ip: Indicates whether your client's IP address is preserved as the source. The value is ``true`` or ``false`` . - If ``true`` , your client's IP address is used when you connect to a resource. - If ``false`` , the elastic network interface IP address is used when you connect to a resource. Default: ``true``
        :param security_group_ids: One or more security groups to associate with the endpoint. If you don't specify a security group, the default security group for your VPC will be associated with the endpoint.
        :param tags: The tags to apply to the EC2 Instance Connect Endpoint during creation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_instance_connect_endpoint_props = ec2.CfnInstanceConnectEndpointProps(
                subnet_id="subnetId",
            
                # the properties below are optional
                client_token="clientToken",
                preserve_client_ip=False,
                security_group_ids=["securityGroupIds"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__78086551229af23659e2463ffd3801975d2b07247065af08d90eebf9e7f66ef8)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument client_token", value=client_token, expected_type=type_hints["client_token"])
            check_type(argname="argument preserve_client_ip", value=preserve_client_ip, expected_type=type_hints["preserve_client_ip"])
            check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if client_token is not None:
            self._values["client_token"] = client_token
        if preserve_client_ip is not None:
            self._values["preserve_client_ip"] = preserve_client_ip
        if security_group_ids is not None:
            self._values["security_group_ids"] = security_group_ids
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet in which to create the EC2 Instance Connect Endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html#cfn-ec2-instanceconnectendpoint-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def client_token(self) -> typing.Optional[builtins.str]:
        '''Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html#cfn-ec2-instanceconnectendpoint-clienttoken
        '''
        result = self._values.get("client_token")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def preserve_client_ip(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether your client's IP address is preserved as the source. The value is ``true`` or ``false`` .

        - If ``true`` , your client's IP address is used when you connect to a resource.
        - If ``false`` , the elastic network interface IP address is used when you connect to a resource.

        Default: ``true``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html#cfn-ec2-instanceconnectendpoint-preserveclientip
        '''
        result = self._values.get("preserve_client_ip")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''One or more security groups to associate with the endpoint.

        If you don't specify a security group, the default security group for your VPC will be associated with the endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html#cfn-ec2-instanceconnectendpoint-securitygroupids
        '''
        result = self._values.get("security_group_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the EC2 Instance Connect Endpoint during creation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instanceconnectendpoint.html#cfn-ec2-instanceconnectendpoint-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnInstanceConnectEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnInstanceProps",
    jsii_struct_bases=[],
    name_mapping={
        "additional_info": "additionalInfo",
        "affinity": "affinity",
        "availability_zone": "availabilityZone",
        "block_device_mappings": "blockDeviceMappings",
        "cpu_options": "cpuOptions",
        "credit_specification": "creditSpecification",
        "disable_api_termination": "disableApiTermination",
        "ebs_optimized": "ebsOptimized",
        "elastic_gpu_specifications": "elasticGpuSpecifications",
        "elastic_inference_accelerators": "elasticInferenceAccelerators",
        "enclave_options": "enclaveOptions",
        "hibernation_options": "hibernationOptions",
        "host_id": "hostId",
        "host_resource_group_arn": "hostResourceGroupArn",
        "iam_instance_profile": "iamInstanceProfile",
        "image_id": "imageId",
        "instance_initiated_shutdown_behavior": "instanceInitiatedShutdownBehavior",
        "instance_type": "instanceType",
        "ipv6_address_count": "ipv6AddressCount",
        "ipv6_addresses": "ipv6Addresses",
        "kernel_id": "kernelId",
        "key_name": "keyName",
        "launch_template": "launchTemplate",
        "license_specifications": "licenseSpecifications",
        "monitoring": "monitoring",
        "network_interfaces": "networkInterfaces",
        "placement_group_name": "placementGroupName",
        "private_dns_name_options": "privateDnsNameOptions",
        "private_ip_address": "privateIpAddress",
        "propagate_tags_to_volume_on_creation": "propagateTagsToVolumeOnCreation",
        "ramdisk_id": "ramdiskId",
        "security_group_ids": "securityGroupIds",
        "security_groups": "securityGroups",
        "source_dest_check": "sourceDestCheck",
        "ssm_associations": "ssmAssociations",
        "subnet_id": "subnetId",
        "tags": "tags",
        "tenancy": "tenancy",
        "user_data": "userData",
        "volumes": "volumes",
    },
)
class CfnInstanceProps:
    def __init__(
        self,
        *,
        additional_info: typing.Optional[builtins.str] = None,
        affinity: typing.Optional[builtins.str] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CpuOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CreditSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticGpuSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticInferenceAcceleratorProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.EnclaveOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.HibernationOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        host_id: typing.Optional[builtins.str] = None,
        host_resource_group_arn: typing.Optional[builtins.str] = None,
        iam_instance_profile: typing.Optional[builtins.str] = None,
        image_id: typing.Optional[builtins.str] = None,
        instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional[builtins.str] = None,
        ipv6_address_count: typing.Optional[jsii.Number] = None,
        ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        kernel_id: typing.Optional[builtins.str] = None,
        key_name: typing.Optional[builtins.str] = None,
        launch_template: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LaunchTemplateSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LicenseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        monitoring: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.NetworkInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        placement_group_name: typing.Optional[builtins.str] = None,
        private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.PrivateDnsNameOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        propagate_tags_to_volume_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ramdisk_id: typing.Optional[builtins.str] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
        source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ssm_associations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.SsmAssociationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        subnet_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        tenancy: typing.Optional[builtins.str] = None,
        user_data: typing.Optional[builtins.str] = None,
        volumes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.VolumeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnInstance``.

        :param additional_info: This property is reserved for internal use. If you use it, the stack fails with this error: ``Bad property set: [Testing this property] (Service: AmazonEC2; Status Code: 400; Error Code: InvalidParameterCombination; Request ID: 0XXXXXX-49c7-4b40-8bcc-76885dcXXXXX)`` .
        :param affinity: Indicates whether the instance is associated with a dedicated host. If you want the instance to always restart on the same host on which it was launched, specify ``host`` . If you want the instance to restart on any available host, but try to launch onto the last host it ran on (on a best-effort basis), specify ``default`` .
        :param availability_zone: The Availability Zone of the instance. If not specified, an Availability Zone will be automatically chosen for you based on the load balancing criteria for the Region. This parameter is not supported by `DescribeImageAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html>`_ .
        :param block_device_mappings: The block device mapping entries that defines the block devices to attach to the instance at launch. By default, the block devices specified in the block device mapping for the AMI are used. You can override the AMI block device mapping using the instance block device mapping. For the root volume, you can override only the volume size, volume type, volume encryption settings, and the ``DeleteOnTermination`` setting. .. epigraph:: After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .
        :param cpu_options: The CPU options for the instance. For more information, see `Optimize CPU options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
        :param credit_specification: The credit option for CPU usage of the burstable performance instance. Valid values are ``standard`` and ``unlimited`` . To change this attribute after launch, use `ModifyInstanceCreditSpecification <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceCreditSpecification.html>`_ . For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ in the *Amazon EC2 User Guide* . Default: ``standard`` (T2 instances) or ``unlimited`` (T3/T3a/T4g instances) For T3 instances with ``host`` tenancy, only ``standard`` is supported.
        :param disable_api_termination: If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can. To change this attribute after launch, use `ModifyInstanceAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html>`_ . Alternatively, if you set ``InstanceInitiatedShutdownBehavior`` to ``terminate`` , you can terminate the instance by running the shutdown command from the instance. Default: ``false``
        :param ebs_optimized: Indicates whether the instance is optimized for Amazon EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance. Default: ``false``
        :param elastic_gpu_specifications: Deprecated. .. epigraph:: Amazon Elastic Graphics reached end of life on January 8, 2024. For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.
        :param elastic_inference_accelerators: An elastic inference accelerator to associate with the instance. Elastic inference accelerators are a resource you can attach to your Amazon EC2 instances to accelerate your Deep Learning (DL) inference workloads. You cannot specify accelerators from different generations in the same request. .. epigraph:: Starting April 15, 2023, AWS will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, Amazon ECS, or Amazon EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.
        :param enclave_options: Indicates whether the instance is enabled for AWS Nitro Enclaves.
        :param hibernation_options: Indicates whether an instance is enabled for hibernation. This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html>`_ . For more information, see `Hibernate your instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon EC2 User Guide* . You can't enable hibernation and AWS Nitro Enclaves on the same instance.
        :param host_id: If you specify host for the ``Affinity`` property, the ID of a dedicated host that the instance is associated with. If you don't specify an ID, Amazon EC2 launches the instance onto any available, compatible dedicated host in your account. This type of launch is called an untargeted launch. Note that for untargeted launches, you must have a compatible, dedicated host available to successfully launch instances.
        :param host_resource_group_arn: The ARN of the host resource group in which to launch the instances. If you specify a host resource group ARN, omit the *Tenancy* parameter or set it to ``host`` .
        :param iam_instance_profile: The name of an IAM instance profile. To create a new IAM instance profile, use the `AWS::IAM::InstanceProfile <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html>`_ resource.
        :param image_id: The ID of the AMI. An AMI ID is required to launch an instance and must be specified here or in a launch template.
        :param instance_initiated_shutdown_behavior: Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Default: ``stop``
        :param instance_type: The instance type. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* . When you change your EBS-backed instance type, instance restart or replacement behavior depends on the instance type compatibility between the old and new types. An instance with an instance store volume as the root volume is always replaced. For more information, see `Change the instance type <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html>`_ in the *Amazon EC2 User Guide* .
        :param ipv6_address_count: The number of IPv6 addresses to associate with the primary network interface. Amazon EC2 chooses the IPv6 addresses from the range of your subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch. You cannot specify this option and the network interfaces option in the same request.
        :param ipv6_addresses: The IPv6 addresses from the range of the subnet to associate with the primary network interface. You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch. You cannot specify this option and the network interfaces option in the same request.
        :param kernel_id: The ID of the kernel. .. epigraph:: We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .
        :param key_name: The name of the key pair. You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ . .. epigraph:: If you do not specify a key pair, you can't connect to the instance unless you choose an AMI that is configured to allow users another way to log in.
        :param launch_template: The launch template to use to launch the instances. Any parameters that you specify in the AWS CloudFormation template override the same parameters in the launch template. You can specify either the name or ID of a launch template, but not both.
        :param license_specifications: The license configurations.
        :param monitoring: Specifies whether detailed monitoring is enabled for the instance. Specify ``true`` to enable detailed monitoring. Otherwise, basic monitoring is enabled. For more information about detailed monitoring, see `Enable or turn off detailed monitoring for your instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html>`_ in the *Amazon EC2 User Guide* .
        :param network_interfaces: The network interfaces to associate with the instance. .. epigraph:: If you use this property to point to a network interface, you must terminate the original interface before attaching a new one to allow the update of the instance to succeed. If this resource has a public IP address and is also in a VPC that is defined in the same template, you must use the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ to declare a dependency on the VPC-gateway attachment.
        :param placement_group_name: The name of an existing placement group that you want to launch the instance into (cluster | partition | spread).
        :param private_dns_name_options: The options for the instance hostname.
        :param private_ip_address: The primary IPv4 address. You must specify a value from the IPv4 address range of the subnet. Only one private IP address can be designated as primary. You can't specify this option if you've specified the option to designate a private IP address as the primary IP address in a network interface specification. You cannot specify this option if you're launching more than one instance in the request. You cannot specify this option and the network interfaces option in the same request. If you make an update to an instance that requires replacement, you must assign a new private IP address. During a replacement, AWS CloudFormation creates a new instance but doesn't delete the old instance until the stack has successfully updated. If the stack update fails, AWS CloudFormation uses the old instance to roll back the stack to the previous working state. The old and new instances cannot have the same private IP address.
        :param propagate_tags_to_volume_on_creation: Indicates whether to assign the tags from the instance to all of the volumes attached to the instance at launch. If you specify ``true`` and you assign tags to the instance, those tags are automatically assigned to all of the volumes that you attach to the instance at launch. If you specify ``false`` , those tags are not assigned to the attached volumes.
        :param ramdisk_id: The ID of the RAM disk to select. Some kernels require additional drivers at launch. Check the kernel requirements for information about whether you need to specify a RAM disk. To find kernel requirements, go to the AWS Resource Center and search for the kernel ID. .. epigraph:: We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .
        :param security_group_ids: The IDs of the security groups. You can specify the IDs of existing security groups and references to resources created by the stack template. If you specify a network interface, you must specify any security groups as part of the network interface.
        :param security_groups: [Default VPC] The names of the security groups. For a nondefault VPC, you must use security group IDs instead. You cannot specify this option and the network interfaces option in the same request. The list can contain both the name of existing Amazon EC2 security groups or references to AWS::EC2::SecurityGroup resources created in the template. Default: Amazon EC2 uses the default security group.
        :param source_dest_check: 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.
        :param ssm_associations: The SSM `document <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ssm-document.html>`_ and parameter values in AWS Systems Manager to associate with this instance. To use this property, you must specify an IAM instance profile role for the instance. For more information, see `Create an IAM instance profile for Systems Manager <https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-configuring-access-role.html>`_ in the *AWS Systems Manager User Guide* . .. epigraph:: You can associate only one document with an instance.
        :param subnet_id: The ID of the subnet to launch the instance into. If you specify a network interface, you must specify any subnets as part of the network interface.
        :param tags: The tags to add to the instance. These tags are not applied to the EBS volumes, such as the root volume, unless `PropagateTagsToVolumeOnCreation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html#cfn-ec2-instance-propagatetagstovolumeoncreation>`_ is ``true`` .
        :param tenancy: The tenancy of the instance. An instance with a tenancy of ``dedicated`` runs on single-tenant hardware.
        :param user_data: The parameters or scripts to store as user data. Any scripts in user data are run when you launch the instance. User data is limited to 16 KB. You must provide base64-encoded text. For more information, see `Fn::Base64 <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-base64.html>`_ . If the root volume is an EBS volume and you update user data, CloudFormation restarts the instance. If the root volume is an instance store volume and you update user data, the instance is replaced.
        :param volumes: The volumes to attach to the instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_instance_props = ec2.CfnInstanceProps(
                additional_info="additionalInfo",
                affinity="affinity",
                availability_zone="availabilityZone",
                block_device_mappings=[ec2.CfnInstance.BlockDeviceMappingProperty(
                    device_name="deviceName",
            
                    # the properties below are optional
                    ebs=ec2.CfnInstance.EbsProperty(
                        delete_on_termination=False,
                        encrypted=False,
                        iops=123,
                        kms_key_id="kmsKeyId",
                        snapshot_id="snapshotId",
                        volume_size=123,
                        volume_type="volumeType"
                    ),
                    no_device=ec2.CfnInstance.NoDeviceProperty(),
                    virtual_name="virtualName"
                )],
                cpu_options=ec2.CfnInstance.CpuOptionsProperty(
                    core_count=123,
                    threads_per_core=123
                ),
                credit_specification=ec2.CfnInstance.CreditSpecificationProperty(
                    cpu_credits="cpuCredits"
                ),
                disable_api_termination=False,
                ebs_optimized=False,
                elastic_gpu_specifications=[ec2.CfnInstance.ElasticGpuSpecificationProperty(
                    type="type"
                )],
                elastic_inference_accelerators=[ec2.CfnInstance.ElasticInferenceAcceleratorProperty(
                    type="type",
            
                    # the properties below are optional
                    count=123
                )],
                enclave_options=ec2.CfnInstance.EnclaveOptionsProperty(
                    enabled=False
                ),
                hibernation_options=ec2.CfnInstance.HibernationOptionsProperty(
                    configured=False
                ),
                host_id="hostId",
                host_resource_group_arn="hostResourceGroupArn",
                iam_instance_profile="iamInstanceProfile",
                image_id="imageId",
                instance_initiated_shutdown_behavior="instanceInitiatedShutdownBehavior",
                instance_type="instanceType",
                ipv6_address_count=123,
                ipv6_addresses=[ec2.CfnInstance.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )],
                kernel_id="kernelId",
                key_name="keyName",
                launch_template=ec2.CfnInstance.LaunchTemplateSpecificationProperty(
                    version="version",
            
                    # the properties below are optional
                    launch_template_id="launchTemplateId",
                    launch_template_name="launchTemplateName"
                ),
                license_specifications=[ec2.CfnInstance.LicenseSpecificationProperty(
                    license_configuration_arn="licenseConfigurationArn"
                )],
                monitoring=False,
                network_interfaces=[ec2.CfnInstance.NetworkInterfaceProperty(
                    device_index="deviceIndex",
            
                    # the properties below are optional
                    associate_carrier_ip_address=False,
                    associate_public_ip_address=False,
                    delete_on_termination=False,
                    description="description",
                    group_set=["groupSet"],
                    ipv6_address_count=123,
                    ipv6_addresses=[ec2.CfnInstance.InstanceIpv6AddressProperty(
                        ipv6_address="ipv6Address"
                    )],
                    network_interface_id="networkInterfaceId",
                    private_ip_address="privateIpAddress",
                    private_ip_addresses=[ec2.CfnInstance.PrivateIpAddressSpecificationProperty(
                        primary=False,
                        private_ip_address="privateIpAddress"
                    )],
                    secondary_private_ip_address_count=123,
                    subnet_id="subnetId"
                )],
                placement_group_name="placementGroupName",
                private_dns_name_options=ec2.CfnInstance.PrivateDnsNameOptionsProperty(
                    enable_resource_name_dns_aaaa_record=False,
                    enable_resource_name_dns_aRecord=False,
                    hostname_type="hostnameType"
                ),
                private_ip_address="privateIpAddress",
                propagate_tags_to_volume_on_creation=False,
                ramdisk_id="ramdiskId",
                security_group_ids=["securityGroupIds"],
                security_groups=["securityGroups"],
                source_dest_check=False,
                ssm_associations=[ec2.CfnInstance.SsmAssociationProperty(
                    document_name="documentName",
            
                    # the properties below are optional
                    association_parameters=[ec2.CfnInstance.AssociationParameterProperty(
                        key="key",
                        value=["value"]
                    )]
                )],
                subnet_id="subnetId",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                tenancy="tenancy",
                user_data="userData",
                volumes=[ec2.CfnInstance.VolumeProperty(
                    device="device",
                    volume_id="volumeId"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__605ba8f22e222289aa0ed61b03690aaf9a4e8eabb86a9ba2b63d10f2bbee2305)
            check_type(argname="argument additional_info", value=additional_info, expected_type=type_hints["additional_info"])
            check_type(argname="argument affinity", value=affinity, expected_type=type_hints["affinity"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument block_device_mappings", value=block_device_mappings, expected_type=type_hints["block_device_mappings"])
            check_type(argname="argument cpu_options", value=cpu_options, expected_type=type_hints["cpu_options"])
            check_type(argname="argument credit_specification", value=credit_specification, expected_type=type_hints["credit_specification"])
            check_type(argname="argument disable_api_termination", value=disable_api_termination, expected_type=type_hints["disable_api_termination"])
            check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
            check_type(argname="argument elastic_gpu_specifications", value=elastic_gpu_specifications, expected_type=type_hints["elastic_gpu_specifications"])
            check_type(argname="argument elastic_inference_accelerators", value=elastic_inference_accelerators, expected_type=type_hints["elastic_inference_accelerators"])
            check_type(argname="argument enclave_options", value=enclave_options, expected_type=type_hints["enclave_options"])
            check_type(argname="argument hibernation_options", value=hibernation_options, expected_type=type_hints["hibernation_options"])
            check_type(argname="argument host_id", value=host_id, expected_type=type_hints["host_id"])
            check_type(argname="argument host_resource_group_arn", value=host_resource_group_arn, expected_type=type_hints["host_resource_group_arn"])
            check_type(argname="argument iam_instance_profile", value=iam_instance_profile, expected_type=type_hints["iam_instance_profile"])
            check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
            check_type(argname="argument instance_initiated_shutdown_behavior", value=instance_initiated_shutdown_behavior, expected_type=type_hints["instance_initiated_shutdown_behavior"])
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument ipv6_address_count", value=ipv6_address_count, expected_type=type_hints["ipv6_address_count"])
            check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
            check_type(argname="argument kernel_id", value=kernel_id, expected_type=type_hints["kernel_id"])
            check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
            check_type(argname="argument launch_template", value=launch_template, expected_type=type_hints["launch_template"])
            check_type(argname="argument license_specifications", value=license_specifications, expected_type=type_hints["license_specifications"])
            check_type(argname="argument monitoring", value=monitoring, expected_type=type_hints["monitoring"])
            check_type(argname="argument network_interfaces", value=network_interfaces, expected_type=type_hints["network_interfaces"])
            check_type(argname="argument placement_group_name", value=placement_group_name, expected_type=type_hints["placement_group_name"])
            check_type(argname="argument private_dns_name_options", value=private_dns_name_options, expected_type=type_hints["private_dns_name_options"])
            check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            check_type(argname="argument propagate_tags_to_volume_on_creation", value=propagate_tags_to_volume_on_creation, expected_type=type_hints["propagate_tags_to_volume_on_creation"])
            check_type(argname="argument ramdisk_id", value=ramdisk_id, expected_type=type_hints["ramdisk_id"])
            check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument source_dest_check", value=source_dest_check, expected_type=type_hints["source_dest_check"])
            check_type(argname="argument ssm_associations", value=ssm_associations, expected_type=type_hints["ssm_associations"])
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument volumes", value=volumes, expected_type=type_hints["volumes"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if additional_info is not None:
            self._values["additional_info"] = additional_info
        if affinity is not None:
            self._values["affinity"] = affinity
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if block_device_mappings is not None:
            self._values["block_device_mappings"] = block_device_mappings
        if cpu_options is not None:
            self._values["cpu_options"] = cpu_options
        if credit_specification is not None:
            self._values["credit_specification"] = credit_specification
        if disable_api_termination is not None:
            self._values["disable_api_termination"] = disable_api_termination
        if ebs_optimized is not None:
            self._values["ebs_optimized"] = ebs_optimized
        if elastic_gpu_specifications is not None:
            self._values["elastic_gpu_specifications"] = elastic_gpu_specifications
        if elastic_inference_accelerators is not None:
            self._values["elastic_inference_accelerators"] = elastic_inference_accelerators
        if enclave_options is not None:
            self._values["enclave_options"] = enclave_options
        if hibernation_options is not None:
            self._values["hibernation_options"] = hibernation_options
        if host_id is not None:
            self._values["host_id"] = host_id
        if host_resource_group_arn is not None:
            self._values["host_resource_group_arn"] = host_resource_group_arn
        if iam_instance_profile is not None:
            self._values["iam_instance_profile"] = iam_instance_profile
        if image_id is not None:
            self._values["image_id"] = image_id
        if instance_initiated_shutdown_behavior is not None:
            self._values["instance_initiated_shutdown_behavior"] = instance_initiated_shutdown_behavior
        if instance_type is not None:
            self._values["instance_type"] = instance_type
        if ipv6_address_count is not None:
            self._values["ipv6_address_count"] = ipv6_address_count
        if ipv6_addresses is not None:
            self._values["ipv6_addresses"] = ipv6_addresses
        if kernel_id is not None:
            self._values["kernel_id"] = kernel_id
        if key_name is not None:
            self._values["key_name"] = key_name
        if launch_template is not None:
            self._values["launch_template"] = launch_template
        if license_specifications is not None:
            self._values["license_specifications"] = license_specifications
        if monitoring is not None:
            self._values["monitoring"] = monitoring
        if network_interfaces is not None:
            self._values["network_interfaces"] = network_interfaces
        if placement_group_name is not None:
            self._values["placement_group_name"] = placement_group_name
        if private_dns_name_options is not None:
            self._values["private_dns_name_options"] = private_dns_name_options
        if private_ip_address is not None:
            self._values["private_ip_address"] = private_ip_address
        if propagate_tags_to_volume_on_creation is not None:
            self._values["propagate_tags_to_volume_on_creation"] = propagate_tags_to_volume_on_creation
        if ramdisk_id is not None:
            self._values["ramdisk_id"] = ramdisk_id
        if security_group_ids is not None:
            self._values["security_group_ids"] = security_group_ids
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if source_dest_check is not None:
            self._values["source_dest_check"] = source_dest_check
        if ssm_associations is not None:
            self._values["ssm_associations"] = ssm_associations
        if subnet_id is not None:
            self._values["subnet_id"] = subnet_id
        if tags is not None:
            self._values["tags"] = tags
        if tenancy is not None:
            self._values["tenancy"] = tenancy
        if user_data is not None:
            self._values["user_data"] = user_data
        if volumes is not None:
            self._values["volumes"] = volumes

    @builtins.property
    def additional_info(self) -> typing.Optional[builtins.str]:
        '''This property is reserved for internal use.

        If you use it, the stack fails with this error: ``Bad property set: [Testing this property] (Service: AmazonEC2; Status Code: 400; Error Code: InvalidParameterCombination; Request ID: 0XXXXXX-49c7-4b40-8bcc-76885dcXXXXX)`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-additionalinfo
        '''
        result = self._values.get("additional_info")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def affinity(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the instance is associated with a dedicated host.

        If you want the instance to always restart on the same host on which it was launched, specify ``host`` . If you want the instance to restart on any available host, but try to launch onto the last host it ran on (on a best-effort basis), specify ``default`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-affinity
        '''
        result = self._values.get("affinity")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone of the instance.

        If not specified, an Availability Zone will be automatically chosen for you based on the load balancing criteria for the Region.

        This parameter is not supported by `DescribeImageAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-availabilityzone
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def block_device_mappings(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.BlockDeviceMappingProperty]]]]:
        '''The block device mapping entries that defines the block devices to attach to the instance at launch.

        By default, the block devices specified in the block device mapping for the AMI are used. You can override the AMI block device mapping using the instance block device mapping. For the root volume, you can override only the volume size, volume type, volume encryption settings, and the ``DeleteOnTermination`` setting.
        .. epigraph::

           After the instance is running, you can modify only the ``DeleteOnTermination`` parameter for the attached volumes without interrupting the instance. Modifying any other parameter results in instance `replacement <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-replacement>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-blockdevicemappings
        '''
        result = self._values.get("block_device_mappings")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.BlockDeviceMappingProperty]]]], result)

    @builtins.property
    def cpu_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CpuOptionsProperty]]:
        '''The CPU options for the instance.

        For more information, see `Optimize CPU options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-cpuoptions
        '''
        result = self._values.get("cpu_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CpuOptionsProperty]], result)

    @builtins.property
    def credit_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CreditSpecificationProperty]]:
        '''The credit option for CPU usage of the burstable performance instance.

        Valid values are ``standard`` and ``unlimited`` . To change this attribute after launch, use `ModifyInstanceCreditSpecification <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceCreditSpecification.html>`_ . For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ in the *Amazon EC2 User Guide* .

        Default: ``standard`` (T2 instances) or ``unlimited`` (T3/T3a/T4g instances)

        For T3 instances with ``host`` tenancy, only ``standard`` is supported.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-creditspecification
        '''
        result = self._values.get("credit_specification")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CreditSpecificationProperty]], result)

    @builtins.property
    def disable_api_termination(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API;

        otherwise, you can. To change this attribute after launch, use `ModifyInstanceAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html>`_ . Alternatively, if you set ``InstanceInitiatedShutdownBehavior`` to ``terminate`` , you can terminate the instance by running the shutdown command from the instance.

        Default: ``false``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-disableapitermination
        '''
        result = self._values.get("disable_api_termination")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def ebs_optimized(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the instance is optimized for Amazon EBS I/O.

        This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance.

        Default: ``false``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-ebsoptimized
        '''
        result = self._values.get("ebs_optimized")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def elastic_gpu_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticGpuSpecificationProperty]]]]:
        '''Deprecated.

        .. epigraph::

           Amazon Elastic Graphics reached end of life on January 8, 2024. For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-elasticgpuspecifications
        '''
        result = self._values.get("elastic_gpu_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticGpuSpecificationProperty]]]], result)

    @builtins.property
    def elastic_inference_accelerators(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticInferenceAcceleratorProperty]]]]:
        '''An elastic inference accelerator to associate with the instance.

        Elastic inference accelerators are a resource you can attach to your Amazon EC2 instances to accelerate your Deep Learning (DL) inference workloads.

        You cannot specify accelerators from different generations in the same request.
        .. epigraph::

           Starting April 15, 2023, AWS will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, Amazon ECS, or Amazon EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-elasticinferenceaccelerators
        '''
        result = self._values.get("elastic_inference_accelerators")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticInferenceAcceleratorProperty]]]], result)

    @builtins.property
    def enclave_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.EnclaveOptionsProperty]]:
        '''Indicates whether the instance is enabled for AWS Nitro Enclaves.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-enclaveoptions
        '''
        result = self._values.get("enclave_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.EnclaveOptionsProperty]], result)

    @builtins.property
    def hibernation_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.HibernationOptionsProperty]]:
        '''Indicates whether an instance is enabled for hibernation.

        This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html>`_ . For more information, see `Hibernate your instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon EC2 User Guide* .

        You can't enable hibernation and AWS Nitro Enclaves on the same instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-hibernationoptions
        '''
        result = self._values.get("hibernation_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.HibernationOptionsProperty]], result)

    @builtins.property
    def host_id(self) -> typing.Optional[builtins.str]:
        '''If you specify host for the ``Affinity`` property, the ID of a dedicated host that the instance is associated with.

        If you don't specify an ID, Amazon EC2 launches the instance onto any available, compatible dedicated host in your account. This type of launch is called an untargeted launch. Note that for untargeted launches, you must have a compatible, dedicated host available to successfully launch instances.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-hostid
        '''
        result = self._values.get("host_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def host_resource_group_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the host resource group in which to launch the instances.

        If you specify a host resource group ARN, omit the *Tenancy* parameter or set it to ``host`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-hostresourcegrouparn
        '''
        result = self._values.get("host_resource_group_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def iam_instance_profile(self) -> typing.Optional[builtins.str]:
        '''The name of an IAM instance profile.

        To create a new IAM instance profile, use the `AWS::IAM::InstanceProfile <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html>`_ resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-iaminstanceprofile
        '''
        result = self._values.get("iam_instance_profile")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def image_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the AMI.

        An AMI ID is required to launch an instance and must be specified here or in a launch template.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-imageid
        '''
        result = self._values.get("image_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_initiated_shutdown_behavior(self) -> typing.Optional[builtins.str]:
        '''Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown).

        Default: ``stop``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-instanceinitiatedshutdownbehavior
        '''
        result = self._values.get("instance_initiated_shutdown_behavior")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_type(self) -> typing.Optional[builtins.str]:
        '''The instance type. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .

        When you change your EBS-backed instance type, instance restart or replacement behavior depends on the instance type compatibility between the old and new types. An instance with an instance store volume as the root volume is always replaced. For more information, see `Change the instance type <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-resize.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-instancetype
        '''
        result = self._values.get("instance_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv6 addresses to associate with the primary network interface.

        Amazon EC2 chooses the IPv6 addresses from the range of your subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch.

        You cannot specify this option and the network interfaces option in the same request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-ipv6addresscount
        '''
        result = self._values.get("ipv6_address_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.InstanceIpv6AddressProperty]]]]:
        '''The IPv6 addresses from the range of the subnet to associate with the primary network interface.

        You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch.

        You cannot specify this option and the network interfaces option in the same request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-ipv6addresses
        '''
        result = self._values.get("ipv6_addresses")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.InstanceIpv6AddressProperty]]]], result)

    @builtins.property
    def kernel_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the kernel.

        .. epigraph::

           We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-kernelid
        '''
        result = self._values.get("kernel_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_name(self) -> typing.Optional[builtins.str]:
        '''The name of the key pair. You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ .

        .. epigraph::

           If you do not specify a key pair, you can't connect to the instance unless you choose an AMI that is configured to allow users another way to log in.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-keyname
        '''
        result = self._values.get("key_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def launch_template(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.LaunchTemplateSpecificationProperty]]:
        '''The launch template to use to launch the instances.

        Any parameters that you specify in the AWS CloudFormation template override the same parameters in the launch template. You can specify either the name or ID of a launch template, but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-launchtemplate
        '''
        result = self._values.get("launch_template")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.LaunchTemplateSpecificationProperty]], result)

    @builtins.property
    def license_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.LicenseSpecificationProperty]]]]:
        '''The license configurations.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-licensespecifications
        '''
        result = self._values.get("license_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.LicenseSpecificationProperty]]]], result)

    @builtins.property
    def monitoring(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Specifies whether detailed monitoring is enabled for the instance.

        Specify ``true`` to enable detailed monitoring. Otherwise, basic monitoring is enabled. For more information about detailed monitoring, see `Enable or turn off detailed monitoring for your instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-monitoring
        '''
        result = self._values.get("monitoring")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def network_interfaces(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.NetworkInterfaceProperty]]]]:
        '''The network interfaces to associate with the instance.

        .. epigraph::

           If you use this property to point to a network interface, you must terminate the original interface before attaching a new one to allow the update of the instance to succeed.

           If this resource has a public IP address and is also in a VPC that is defined in the same template, you must use the `DependsOn Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html>`_ to declare a dependency on the VPC-gateway attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-networkinterfaces
        '''
        result = self._values.get("network_interfaces")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.NetworkInterfaceProperty]]]], result)

    @builtins.property
    def placement_group_name(self) -> typing.Optional[builtins.str]:
        '''The name of an existing placement group that you want to launch the instance into (cluster | partition | spread).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-placementgroupname
        '''
        result = self._values.get("placement_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def private_dns_name_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.PrivateDnsNameOptionsProperty]]:
        '''The options for the instance hostname.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-privatednsnameoptions
        '''
        result = self._values.get("private_dns_name_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.PrivateDnsNameOptionsProperty]], result)

    @builtins.property
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The primary IPv4 address. You must specify a value from the IPv4 address range of the subnet.

        Only one private IP address can be designated as primary. You can't specify this option if you've specified the option to designate a private IP address as the primary IP address in a network interface specification. You cannot specify this option if you're launching more than one instance in the request.

        You cannot specify this option and the network interfaces option in the same request.

        If you make an update to an instance that requires replacement, you must assign a new private IP address. During a replacement, AWS CloudFormation creates a new instance but doesn't delete the old instance until the stack has successfully updated. If the stack update fails, AWS CloudFormation uses the old instance to roll back the stack to the previous working state. The old and new instances cannot have the same private IP address.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-privateipaddress
        '''
        result = self._values.get("private_ip_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def propagate_tags_to_volume_on_creation(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to assign the tags from the instance to all of the volumes attached to the instance at launch.

        If you specify ``true`` and you assign tags to the instance, those tags are automatically assigned to all of the volumes that you attach to the instance at launch. If you specify ``false`` , those tags are not assigned to the attached volumes.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-propagatetagstovolumeoncreation
        '''
        result = self._values.get("propagate_tags_to_volume_on_creation")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def ramdisk_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the RAM disk to select.

        Some kernels require additional drivers at launch. Check the kernel requirements for information about whether you need to specify a RAM disk. To find kernel requirements, go to the AWS Resource Center and search for the kernel ID.
        .. epigraph::

           We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `PV-GRUB <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-ramdiskid
        '''
        result = self._values.get("ramdisk_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups.

        You can specify the IDs of existing security groups and references to resources created by the stack template.

        If you specify a network interface, you must specify any security groups as part of the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-securitygroupids
        '''
        result = self._values.get("security_group_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List[builtins.str]]:
        '''[Default VPC] The names of the security groups. For a nondefault VPC, you must use security group IDs instead.

        You cannot specify this option and the network interfaces option in the same request. The list can contain both the name of existing Amazon EC2 security groups or references to AWS::EC2::SecurityGroup resources created in the template.

        Default: Amazon EC2 uses the default security group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-securitygroups
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def source_dest_check(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-sourcedestcheck
        '''
        result = self._values.get("source_dest_check")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def ssm_associations(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.SsmAssociationProperty]]]]:
        '''The SSM `document <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ssm-document.html>`_ and parameter values in AWS Systems Manager to associate with this instance. To use this property, you must specify an IAM instance profile role for the instance. For more information, see `Create an IAM instance profile for Systems Manager <https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-configuring-access-role.html>`_ in the *AWS Systems Manager User Guide* .

        .. epigraph::

           You can associate only one document with an instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-ssmassociations
        '''
        result = self._values.get("ssm_associations")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.SsmAssociationProperty]]]], result)

    @builtins.property
    def subnet_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the subnet to launch the instance into.

        If you specify a network interface, you must specify any subnets as part of the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-subnetid
        '''
        result = self._values.get("subnet_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to add to the instance.

        These tags are not applied to the EBS volumes, such as the root volume, unless `PropagateTagsToVolumeOnCreation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html#cfn-ec2-instance-propagatetagstovolumeoncreation>`_ is ``true`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def tenancy(self) -> typing.Optional[builtins.str]:
        '''The tenancy of the instance.

        An instance with a tenancy of ``dedicated`` runs on single-tenant hardware.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-tenancy
        '''
        result = self._values.get("tenancy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def user_data(self) -> typing.Optional[builtins.str]:
        '''The parameters or scripts to store as user data.

        Any scripts in user data are run when you launch the instance. User data is limited to 16 KB. You must provide base64-encoded text. For more information, see `Fn::Base64 <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-base64.html>`_ .

        If the root volume is an EBS volume and you update user data, CloudFormation restarts the instance. If the root volume is an instance store volume and you update user data, the instance is replaced.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-userdata
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def volumes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.VolumeProperty]]]]:
        '''The volumes to attach to the instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-volumes
        '''
        result = self._values.get("volumes")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.VolumeProperty]]]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnInstanceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnInternetGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnInternetGateway",
):
    '''Allocates an internet gateway for use with a VPC.

    After creating the Internet gateway, you then attach it to a VPC.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-internetgateway.html
    :cloudformationResource: AWS::EC2::InternetGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_internet_gateway = ec2.CfnInternetGateway(self, "MyCfnInternetGateway",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param tags: Any tags to assign to the internet gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa065a029e2c56d70c69099c85a03c8dbfa72480a3684dfdde80dc1f975d73d4)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnInternetGatewayProps(tags=tags)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed6eab34daf843734d508076e53ea4a173d898576d71d9ededed91159fb9ac83)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__691368ae493cae4bac13fdffb80ac19f0d8b2930d5eeb52667c840b0ffd8d536)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrInternetGatewayId")
    def attr_internet_gateway_id(self) -> builtins.str:
        '''The ID of the internet gateway.

        :cloudformationAttribute: InternetGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrInternetGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags to assign to the internet gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa52b53963fd1dabc3e917bdb98f2a4cedbad08b88a859b671f7f475926517ad)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnInternetGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"tags": "tags"},
)
class CfnInternetGatewayProps:
    def __init__(
        self,
        *,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnInternetGateway``.

        :param tags: Any tags to assign to the internet gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-internetgateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_internet_gateway_props = ec2.CfnInternetGatewayProps(
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87a0ecd2999ccef41b6baf7e5e653666a7205cdda8348b4e20f3b1babaf0ecdc)
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags to assign to the internet gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-internetgateway.html#cfn-ec2-internetgateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnInternetGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnKeyPair(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnKeyPair",
):
    '''Specifies a key pair for use with an Amazon Elastic Compute Cloud instance as follows:.

    - To import an existing key pair, include the ``PublicKeyMaterial`` property.
    - To create a new key pair, omit the ``PublicKeyMaterial`` property.

    When you import an existing key pair, you specify the public key material for the key. We assume that you have the private key material for the key. AWS CloudFormation does not create or return the private key material when you import a key pair.

    When you create a new key pair, the private key is saved to AWS Systems Manager Parameter Store, using a parameter with the following name: ``/ec2/keypair/{key_pair_id}`` . For more information about retrieving private key, and the required permissions, see `Create a key pair using AWS CloudFormation <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html#create-key-pair-cloudformation>`_ in the *Amazon EC2 User Guide* .

    When AWS CloudFormation deletes a key pair that was created or imported by a stack, it also deletes the parameter that was used to store the private key material in Parameter Store.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html
    :cloudformationResource: AWS::EC2::KeyPair
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_key_pair = ec2.CfnKeyPair(self, "MyCfnKeyPair",
            key_name="keyName",
        
            # the properties below are optional
            key_format="keyFormat",
            key_type="keyType",
            public_key_material="publicKeyMaterial",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        key_name: builtins.str,
        key_format: typing.Optional[builtins.str] = None,
        key_type: typing.Optional[builtins.str] = None,
        public_key_material: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param key_name: A unique name for the key pair. Constraints: Up to 255 ASCII characters
        :param key_format: The format of the key pair. Default: ``pem`` Default: - "pem"
        :param key_type: The type of key pair. Note that ED25519 keys are not supported for Windows instances. If the ``PublicKeyMaterial`` property is specified, the ``KeyType`` property is ignored, and the key type is inferred from the ``PublicKeyMaterial`` value. Default: ``rsa`` Default: - "rsa"
        :param public_key_material: The public key material. The ``PublicKeyMaterial`` property is used to import a key pair. If this property is not specified, then a new key pair will be created.
        :param tags: The tags to apply to the key pair.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1de6844e799c72712c1e89d9bf245ba313ed7d4d20f1567a28fb58baefc263bd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnKeyPairProps(
            key_name=key_name,
            key_format=key_format,
            key_type=key_type,
            public_key_material=public_key_material,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5cf6da08b13e85cb48d4ec206c808a58477bfb17a74904c2d65e719e3bc479ec)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__463ee579a97a03ee848867c464f5f6bcf3fe4eb6a58284e83950678f19bbdccb)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrKeyFingerprint")
    def attr_key_fingerprint(self) -> builtins.str:
        '''If you created the key pair using Amazon EC2:.

        - For RSA key pairs, the key fingerprint is the SHA-1 digest of the DER encoded private key.
        - For ED25519 key pairs, the key fingerprint is the base64-encoded SHA-256 digest, which is the default for OpenSSH, starting with `OpenSSH 6.8 <https://docs.aws.amazon.com/http://www.openssh.com/txt/release-6.8>`_ .

        If you imported the key pair to Amazon EC2:

        - For RSA key pairs, the key fingerprint is the MD5 public key fingerprint as specified in section 4 of RFC 4716.
        - For ED25519 key pairs, the key fingerprint is the base64-encoded SHA-256 digest, which is the default for OpenSSH, starting with `OpenSSH 6.8 <https://docs.aws.amazon.com/http://www.openssh.com/txt/release-6.8>`_ .

        :cloudformationAttribute: KeyFingerprint
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrKeyFingerprint"))

    @builtins.property
    @jsii.member(jsii_name="attrKeyPairId")
    def attr_key_pair_id(self) -> builtins.str:
        '''The ID of the key pair.

        :cloudformationAttribute: KeyPairId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrKeyPairId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="keyName")
    def key_name(self) -> builtins.str:
        '''A unique name for the key pair.'''
        return typing.cast(builtins.str, jsii.get(self, "keyName"))

    @key_name.setter
    def key_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d3455748348646f19cfe248eb9eaf210442b42702c249cf6616acc5e68aad26)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "keyName", value)

    @builtins.property
    @jsii.member(jsii_name="keyFormat")
    def key_format(self) -> typing.Optional[builtins.str]:
        '''The format of the key pair.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "keyFormat"))

    @key_format.setter
    def key_format(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ad171c997aa3530701089d85081102896744d5e3143730f0dc93d654a1915e0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "keyFormat", value)

    @builtins.property
    @jsii.member(jsii_name="keyType")
    def key_type(self) -> typing.Optional[builtins.str]:
        '''The type of key pair.

        Note that ED25519 keys are not supported for Windows instances.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "keyType"))

    @key_type.setter
    def key_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cbcfd4d60002a30106d3b81cca62fc18c72ce126cc784c4428949c28c704aa5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "keyType", value)

    @builtins.property
    @jsii.member(jsii_name="publicKeyMaterial")
    def public_key_material(self) -> typing.Optional[builtins.str]:
        '''The public key material.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "publicKeyMaterial"))

    @public_key_material.setter
    def public_key_material(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d9cf9951b85314af7c96e9bb1ba925d7301eb80fbd604b9a2fe74681764c4ca)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "publicKeyMaterial", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the key pair.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea1d23ec5083512b19c5063634a5083db2002e1d710831bd5081e17047b055a5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnKeyPairProps",
    jsii_struct_bases=[],
    name_mapping={
        "key_name": "keyName",
        "key_format": "keyFormat",
        "key_type": "keyType",
        "public_key_material": "publicKeyMaterial",
        "tags": "tags",
    },
)
class CfnKeyPairProps:
    def __init__(
        self,
        *,
        key_name: builtins.str,
        key_format: typing.Optional[builtins.str] = None,
        key_type: typing.Optional[builtins.str] = None,
        public_key_material: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnKeyPair``.

        :param key_name: A unique name for the key pair. Constraints: Up to 255 ASCII characters
        :param key_format: The format of the key pair. Default: ``pem`` Default: - "pem"
        :param key_type: The type of key pair. Note that ED25519 keys are not supported for Windows instances. If the ``PublicKeyMaterial`` property is specified, the ``KeyType`` property is ignored, and the key type is inferred from the ``PublicKeyMaterial`` value. Default: ``rsa`` Default: - "rsa"
        :param public_key_material: The public key material. The ``PublicKeyMaterial`` property is used to import a key pair. If this property is not specified, then a new key pair will be created.
        :param tags: The tags to apply to the key pair.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_key_pair_props = ec2.CfnKeyPairProps(
                key_name="keyName",
            
                # the properties below are optional
                key_format="keyFormat",
                key_type="keyType",
                public_key_material="publicKeyMaterial",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3943c76f0fe4743ec822e1f5bcbc09e512b87b7e996b155bace897c7a248d65f)
            check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
            check_type(argname="argument key_format", value=key_format, expected_type=type_hints["key_format"])
            check_type(argname="argument key_type", value=key_type, expected_type=type_hints["key_type"])
            check_type(argname="argument public_key_material", value=public_key_material, expected_type=type_hints["public_key_material"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "key_name": key_name,
        }
        if key_format is not None:
            self._values["key_format"] = key_format
        if key_type is not None:
            self._values["key_type"] = key_type
        if public_key_material is not None:
            self._values["public_key_material"] = public_key_material
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def key_name(self) -> builtins.str:
        '''A unique name for the key pair.

        Constraints: Up to 255 ASCII characters

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html#cfn-ec2-keypair-keyname
        '''
        result = self._values.get("key_name")
        assert result is not None, "Required property 'key_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key_format(self) -> typing.Optional[builtins.str]:
        '''The format of the key pair.

        Default: ``pem``

        :default: - "pem"

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html#cfn-ec2-keypair-keyformat
        '''
        result = self._values.get("key_format")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_type(self) -> typing.Optional[builtins.str]:
        '''The type of key pair. Note that ED25519 keys are not supported for Windows instances.

        If the ``PublicKeyMaterial`` property is specified, the ``KeyType`` property is ignored, and the key type is inferred from the ``PublicKeyMaterial`` value.

        Default: ``rsa``

        :default: - "rsa"

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html#cfn-ec2-keypair-keytype
        '''
        result = self._values.get("key_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def public_key_material(self) -> typing.Optional[builtins.str]:
        '''The public key material.

        The ``PublicKeyMaterial`` property is used to import a key pair. If this property is not specified, then a new key pair will be created.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html#cfn-ec2-keypair-publickeymaterial
        '''
        result = self._values.get("public_key_material")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the key pair.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-keypair.html#cfn-ec2-keypair-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnKeyPairProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnLaunchTemplate(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate",
):
    '''Specifies the properties for creating a launch template.

    The minimum required properties for specifying a launch template are as follows:

    - You must specify at least one property for the launch template data.
    - You do not need to specify a name for the launch template. If you do not specify a name, AWS CloudFormation creates the name for you.

    A launch template can contain some or all of the configuration information to launch an instance. When you launch an instance using a launch template, instance properties that are not specified in the launch template use default values, except the ``ImageId`` property, which has no default value. If you do not specify an AMI ID for the launch template ``ImageId`` property, you must specify an AMI ID for the instance ``ImageId`` property.

    For more information, see `Launch an instance from a launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html>`_ in the *Amazon EC2 User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html
    :cloudformationResource: AWS::EC2::LaunchTemplate
    :exampleMetadata: infused

    Example::

        # cluster: eks.Cluster
        
        
        user_data = """MIME-Version: 1.0
        Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
        
        --==MYBOUNDARY==
        Content-Type: text/x-shellscript; charset="us-ascii"
        
        #!/bin/bash
        echo "Running custom user data script"
        
        --==MYBOUNDARY==--\\
        """
        lt = ec2.CfnLaunchTemplate(self, "LaunchTemplate",
            launch_template_data=ec2.CfnLaunchTemplate.LaunchTemplateDataProperty(
                instance_type="t3.small",
                user_data=Fn.base64(user_data)
            )
        )
        
        cluster.add_nodegroup_capacity("extra-ng",
            launch_template_spec=eks.LaunchTemplateSpec(
                id=lt.ref,
                version=lt.attr_latest_version_number
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        launch_template_data: typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.LaunchTemplateDataProperty", typing.Dict[builtins.str, typing.Any]]],
        launch_template_name: typing.Optional[builtins.str] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        version_description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param launch_template_data: The information for the launch template.
        :param launch_template_name: A name for the launch template.
        :param tag_specifications: The tags to apply to the launch template on creation. To tag the launch template, the resource type must be ``launch-template`` . To specify the tags for the resources that are created when an instance is launched, you must use `TagSpecifications <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications>`_ .
        :param version_description: A description for the first version of the launch template.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9499e80b4296e1479809c7b5bc3f6e9f3d10776c827e6a75fe9385266896c29)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnLaunchTemplateProps(
            launch_template_data=launch_template_data,
            launch_template_name=launch_template_name,
            tag_specifications=tag_specifications,
            version_description=version_description,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__64365a4d33f8b9644946798f4e453417c6eb4405260711ca681d0a287f7b888b)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52ef3ed9f5cbf3b14ad3dc73e435ae5e747acb3109599466e37bbcff4e27a7ad)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrDefaultVersionNumber")
    def attr_default_version_number(self) -> builtins.str:
        '''The default version of the launch template, such as 2.

        The default version of a launch template cannot be specified in AWS CloudFormation . The default version can be set in the Amazon EC2 console or by using the ``modify-launch-template`` AWS CLI command.

        :cloudformationAttribute: DefaultVersionNumber
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDefaultVersionNumber"))

    @builtins.property
    @jsii.member(jsii_name="attrLatestVersionNumber")
    def attr_latest_version_number(self) -> builtins.str:
        '''The latest version of the launch template, such as ``5`` .

        :cloudformationAttribute: LatestVersionNumber
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLatestVersionNumber"))

    @builtins.property
    @jsii.member(jsii_name="attrLaunchTemplateId")
    def attr_launch_template_id(self) -> builtins.str:
        '''The ID of the launch template.

        :cloudformationAttribute: LaunchTemplateId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLaunchTemplateId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateData")
    def launch_template_data(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateDataProperty"]:
        '''The information for the launch template.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateDataProperty"], jsii.get(self, "launchTemplateData"))

    @launch_template_data.setter
    def launch_template_data(
        self,
        value: typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateDataProperty"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__befa19eedcb40ac18e92e5ebabdf929aed5ff042a077e649391f7928cde11c52)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "launchTemplateData", value)

    @builtins.property
    @jsii.member(jsii_name="launchTemplateName")
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''A name for the launch template.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "launchTemplateName"))

    @launch_template_name.setter
    def launch_template_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__759e1e9c4d73c033db7464dee63c4d038e63f222108109d50dadd53ebd12f3b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "launchTemplateName", value)

    @builtins.property
    @jsii.member(jsii_name="tagSpecifications")
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty"]]]]:
        '''The tags to apply to the launch template on creation.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty"]]]], jsii.get(self, "tagSpecifications"))

    @tag_specifications.setter
    def tag_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__317523150461f66f07c47887b103a136f81671637f09dfe0f0c4ab6c2a4d0951)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagSpecifications", value)

    @builtins.property
    @jsii.member(jsii_name="versionDescription")
    def version_description(self) -> typing.Optional[builtins.str]:
        '''A description for the first version of the launch template.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "versionDescription"))

    @version_description.setter
    def version_description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49c5a4ace3815a530085bf4dde1426c80f7fae9aecdeacb884487520d363554f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "versionDescription", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.AcceleratorCountProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorCountProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            :param max: The maximum number of accelerators. To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .
            :param min: The minimum number of accelerators. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratorcount.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_count_property = ec2.CfnLaunchTemplate.AcceleratorCountProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__4606ee5531c0c9932d485bfafc7e54fa72863e3924297890efdef03650e6ec3f)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of accelerators.

            To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratorcount.html#cfn-ec2-launchtemplate-acceleratorcount-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of accelerators.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratorcount.html#cfn-ec2-launchtemplate-acceleratorcount-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorCountProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorTotalMemoryMiBProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            :param max: The maximum amount of accelerator memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of accelerator memory, in MiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratortotalmemorymib.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_total_memory_mi_bProperty = ec2.CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__652e2c3e91267ba7d07bb5894d0dd532ec32eaf113bf034bb60d7e7682fbeb4e)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of accelerator memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratortotalmemorymib.html#cfn-ec2-launchtemplate-acceleratortotalmemorymib-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of accelerator memory, in MiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-acceleratortotalmemorymib.html#cfn-ec2-launchtemplate-acceleratortotalmemorymib-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorTotalMemoryMiBProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class BaselineEbsBandwidthMbpsProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            :param max: The maximum baseline bandwidth, in Mbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum baseline bandwidth, in Mbps. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-baselineebsbandwidthmbps.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                baseline_ebs_bandwidth_mbps_property = ec2.CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f5438a142333f133eef7d17b761ec865c610e35c3898aaeced24d3a33681c704)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum baseline bandwidth, in Mbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-baselineebsbandwidthmbps.html#cfn-ec2-launchtemplate-baselineebsbandwidthmbps-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum baseline bandwidth, in Mbps.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-baselineebsbandwidthmbps.html#cfn-ec2-launchtemplate-baselineebsbandwidthmbps-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BaselineEbsBandwidthMbpsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.BlockDeviceMappingProperty",
        jsii_struct_bases=[],
        name_mapping={
            "device_name": "deviceName",
            "ebs": "ebs",
            "no_device": "noDevice",
            "virtual_name": "virtualName",
        },
    )
    class BlockDeviceMappingProperty:
        def __init__(
            self,
            *,
            device_name: typing.Optional[builtins.str] = None,
            ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.EbsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            no_device: typing.Optional[builtins.str] = None,
            virtual_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a block device mapping for a launch template.

            You must specify ``DeviceName`` plus exactly one of the following properties: ``Ebs`` , ``NoDevice`` , or ``VirtualName`` .

            ``BlockDeviceMapping`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param device_name: The device name (for example, /dev/sdh or xvdh).
            :param ebs: Parameters used to automatically set up EBS volumes when the instance is launched.
            :param no_device: To omit the device from the block device mapping, specify an empty string.
            :param virtual_name: The virtual device name (ephemeralN). Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ephemeral0 and ephemeral1. The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                block_device_mapping_property = ec2.CfnLaunchTemplate.BlockDeviceMappingProperty(
                    device_name="deviceName",
                    ebs=ec2.CfnLaunchTemplate.EbsProperty(
                        delete_on_termination=False,
                        encrypted=False,
                        iops=123,
                        kms_key_id="kmsKeyId",
                        snapshot_id="snapshotId",
                        throughput=123,
                        volume_size=123,
                        volume_type="volumeType"
                    ),
                    no_device="noDevice",
                    virtual_name="virtualName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b11583349c048323414167490ce520ce6a2c88a94f22727256f4c8458131de17)
                check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
                check_type(argname="argument ebs", value=ebs, expected_type=type_hints["ebs"])
                check_type(argname="argument no_device", value=no_device, expected_type=type_hints["no_device"])
                check_type(argname="argument virtual_name", value=virtual_name, expected_type=type_hints["virtual_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if device_name is not None:
                self._values["device_name"] = device_name
            if ebs is not None:
                self._values["ebs"] = ebs
            if no_device is not None:
                self._values["no_device"] = no_device
            if virtual_name is not None:
                self._values["virtual_name"] = virtual_name

        @builtins.property
        def device_name(self) -> typing.Optional[builtins.str]:
            '''The device name (for example, /dev/sdh or xvdh).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html#cfn-ec2-launchtemplate-blockdevicemapping-devicename
            '''
            result = self._values.get("device_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ebs(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EbsProperty"]]:
            '''Parameters used to automatically set up EBS volumes when the instance is launched.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html#cfn-ec2-launchtemplate-blockdevicemapping-ebs
            '''
            result = self._values.get("ebs")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EbsProperty"]], result)

        @builtins.property
        def no_device(self) -> typing.Optional[builtins.str]:
            '''To omit the device from the block device mapping, specify an empty string.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html#cfn-ec2-launchtemplate-blockdevicemapping-nodevice
            '''
            result = self._values.get("no_device")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def virtual_name(self) -> typing.Optional[builtins.str]:
            '''The virtual device name (ephemeralN).

            Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ephemeral0 and ephemeral1. The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html#cfn-ec2-launchtemplate-blockdevicemapping-virtualname
            '''
            result = self._values.get("virtual_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BlockDeviceMappingProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.CapacityReservationSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "capacity_reservation_preference": "capacityReservationPreference",
            "capacity_reservation_target": "capacityReservationTarget",
        },
    )
    class CapacityReservationSpecificationProperty:
        def __init__(
            self,
            *,
            capacity_reservation_preference: typing.Optional[builtins.str] = None,
            capacity_reservation_target: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.CapacityReservationTargetProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies an instance's Capacity Reservation targeting option. You can specify only one option at a time.

            ``CapacityReservationSpecification`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param capacity_reservation_preference: Indicates the instance's Capacity Reservation preferences. Possible preferences include:. - ``open`` - The instance can run in any ``open`` Capacity Reservation that has matching attributes (instance type, platform, Availability Zone). - ``none`` - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.
            :param capacity_reservation_target: Information about the target Capacity Reservation or Capacity Reservation group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                capacity_reservation_specification_property = ec2.CfnLaunchTemplate.CapacityReservationSpecificationProperty(
                    capacity_reservation_preference="capacityReservationPreference",
                    capacity_reservation_target=ec2.CfnLaunchTemplate.CapacityReservationTargetProperty(
                        capacity_reservation_id="capacityReservationId",
                        capacity_reservation_resource_group_arn="capacityReservationResourceGroupArn"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__bc6de33125d8db3c8e4de4a98d2195dad659080fa58344401764fbbcc0fbec96)
                check_type(argname="argument capacity_reservation_preference", value=capacity_reservation_preference, expected_type=type_hints["capacity_reservation_preference"])
                check_type(argname="argument capacity_reservation_target", value=capacity_reservation_target, expected_type=type_hints["capacity_reservation_target"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if capacity_reservation_preference is not None:
                self._values["capacity_reservation_preference"] = capacity_reservation_preference
            if capacity_reservation_target is not None:
                self._values["capacity_reservation_target"] = capacity_reservation_target

        @builtins.property
        def capacity_reservation_preference(self) -> typing.Optional[builtins.str]:
            '''Indicates the instance's Capacity Reservation preferences. Possible preferences include:.

            - ``open`` - The instance can run in any ``open`` Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).
            - ``none`` - The instance avoids running in a Capacity Reservation even if one is available. The instance runs in On-Demand capacity.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationspecification.html#cfn-ec2-launchtemplate-capacityreservationspecification-capacityreservationpreference
            '''
            result = self._values.get("capacity_reservation_preference")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def capacity_reservation_target(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CapacityReservationTargetProperty"]]:
            '''Information about the target Capacity Reservation or Capacity Reservation group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationspecification.html#cfn-ec2-launchtemplate-capacityreservationspecification-capacityreservationtarget
            '''
            result = self._values.get("capacity_reservation_target")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CapacityReservationTargetProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CapacityReservationSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.CapacityReservationTargetProperty",
        jsii_struct_bases=[],
        name_mapping={
            "capacity_reservation_id": "capacityReservationId",
            "capacity_reservation_resource_group_arn": "capacityReservationResourceGroupArn",
        },
    )
    class CapacityReservationTargetProperty:
        def __init__(
            self,
            *,
            capacity_reservation_id: typing.Optional[builtins.str] = None,
            capacity_reservation_resource_group_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a target Capacity Reservation.

            ``CapacityReservationTarget`` is a property of the `Amazon EC2 LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ property type.

            :param capacity_reservation_id: The ID of the Capacity Reservation in which to run the instance.
            :param capacity_reservation_resource_group_arn: The ARN of the Capacity Reservation resource group in which to run the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationtarget.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                capacity_reservation_target_property = ec2.CfnLaunchTemplate.CapacityReservationTargetProperty(
                    capacity_reservation_id="capacityReservationId",
                    capacity_reservation_resource_group_arn="capacityReservationResourceGroupArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__353917311fc0ab9c3e0685812d142d513b65f96d6711992c0ac8bcd30e53a285)
                check_type(argname="argument capacity_reservation_id", value=capacity_reservation_id, expected_type=type_hints["capacity_reservation_id"])
                check_type(argname="argument capacity_reservation_resource_group_arn", value=capacity_reservation_resource_group_arn, expected_type=type_hints["capacity_reservation_resource_group_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if capacity_reservation_id is not None:
                self._values["capacity_reservation_id"] = capacity_reservation_id
            if capacity_reservation_resource_group_arn is not None:
                self._values["capacity_reservation_resource_group_arn"] = capacity_reservation_resource_group_arn

        @builtins.property
        def capacity_reservation_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the Capacity Reservation in which to run the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationtarget.html#cfn-ec2-launchtemplate-capacityreservationtarget-capacityreservationid
            '''
            result = self._values.get("capacity_reservation_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def capacity_reservation_resource_group_arn(
            self,
        ) -> typing.Optional[builtins.str]:
            '''The ARN of the Capacity Reservation resource group in which to run the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-capacityreservationtarget.html#cfn-ec2-launchtemplate-capacityreservationtarget-capacityreservationresourcegrouparn
            '''
            result = self._values.get("capacity_reservation_resource_group_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CapacityReservationTargetProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.ConnectionTrackingSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "tcp_established_timeout": "tcpEstablishedTimeout",
            "udp_stream_timeout": "udpStreamTimeout",
            "udp_timeout": "udpTimeout",
        },
    )
    class ConnectionTrackingSpecificationProperty:
        def __init__(
            self,
            *,
            tcp_established_timeout: typing.Optional[jsii.Number] = None,
            udp_stream_timeout: typing.Optional[jsii.Number] = None,
            udp_timeout: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''A security group connection tracking specification that enables you to set the idle timeout for connection tracking on an Elastic 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* .

            :param tcp_established_timeout: 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.
            :param udp_stream_timeout: 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.
            :param udp_timeout: 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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-connectiontrackingspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                connection_tracking_specification_property = ec2.CfnLaunchTemplate.ConnectionTrackingSpecificationProperty(
                    tcp_established_timeout=123,
                    udp_stream_timeout=123,
                    udp_timeout=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6398756f6434cab0d24e3dd07ede7ad71143f168865c6e672b04edb3a48ca849)
                check_type(argname="argument tcp_established_timeout", value=tcp_established_timeout, expected_type=type_hints["tcp_established_timeout"])
                check_type(argname="argument udp_stream_timeout", value=udp_stream_timeout, expected_type=type_hints["udp_stream_timeout"])
                check_type(argname="argument udp_timeout", value=udp_timeout, expected_type=type_hints["udp_timeout"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if tcp_established_timeout is not None:
                self._values["tcp_established_timeout"] = tcp_established_timeout
            if udp_stream_timeout is not None:
                self._values["udp_stream_timeout"] = udp_stream_timeout
            if udp_timeout is not None:
                self._values["udp_timeout"] = udp_timeout

        @builtins.property
        def tcp_established_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-connectiontrackingspecification.html#cfn-ec2-launchtemplate-connectiontrackingspecification-tcpestablishedtimeout
            '''
            result = self._values.get("tcp_established_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def udp_stream_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-connectiontrackingspecification.html#cfn-ec2-launchtemplate-connectiontrackingspecification-udpstreamtimeout
            '''
            result = self._values.get("udp_stream_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def udp_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-connectiontrackingspecification.html#cfn-ec2-launchtemplate-connectiontrackingspecification-udptimeout
            '''
            result = self._values.get("udp_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ConnectionTrackingSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.CpuOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "amd_sev_snp": "amdSevSnp",
            "core_count": "coreCount",
            "threads_per_core": "threadsPerCore",
        },
    )
    class CpuOptionsProperty:
        def __init__(
            self,
            *,
            amd_sev_snp: typing.Optional[builtins.str] = None,
            core_count: typing.Optional[jsii.Number] = None,
            threads_per_core: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies the CPU options for an instance.

            For more information, see `Optimize CPU options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            ``CpuOptions`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param amd_sev_snp: Indicates whether to enable the instance for AMD SEV-SNP. AMD SEV-SNP is supported with M6a, R6a, and C6a instance types only. For more information, see `AMD SEV-SNP <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html>`_ .
            :param core_count: The number of CPU cores for the instance.
            :param threads_per_core: The number of threads per CPU core. To disable multithreading for the instance, specify a value of ``1`` . Otherwise, specify the default value of ``2`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-cpuoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                cpu_options_property = ec2.CfnLaunchTemplate.CpuOptionsProperty(
                    amd_sev_snp="amdSevSnp",
                    core_count=123,
                    threads_per_core=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__92b7bc91aa2d524d3b92853936f95f64b742fff5188a86cd52b461fbf2d08da5)
                check_type(argname="argument amd_sev_snp", value=amd_sev_snp, expected_type=type_hints["amd_sev_snp"])
                check_type(argname="argument core_count", value=core_count, expected_type=type_hints["core_count"])
                check_type(argname="argument threads_per_core", value=threads_per_core, expected_type=type_hints["threads_per_core"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if amd_sev_snp is not None:
                self._values["amd_sev_snp"] = amd_sev_snp
            if core_count is not None:
                self._values["core_count"] = core_count
            if threads_per_core is not None:
                self._values["threads_per_core"] = threads_per_core

        @builtins.property
        def amd_sev_snp(self) -> typing.Optional[builtins.str]:
            '''Indicates whether to enable the instance for AMD SEV-SNP.

            AMD SEV-SNP is supported with M6a, R6a, and C6a instance types only. For more information, see `AMD SEV-SNP <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/sev-snp.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-cpuoptions.html#cfn-ec2-launchtemplate-cpuoptions-amdsevsnp
            '''
            result = self._values.get("amd_sev_snp")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def core_count(self) -> typing.Optional[jsii.Number]:
            '''The number of CPU cores for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-cpuoptions.html#cfn-ec2-launchtemplate-cpuoptions-corecount
            '''
            result = self._values.get("core_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def threads_per_core(self) -> typing.Optional[jsii.Number]:
            '''The number of threads per CPU core.

            To disable multithreading for the instance, specify a value of ``1`` . Otherwise, specify the default value of ``2`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-cpuoptions.html#cfn-ec2-launchtemplate-cpuoptions-threadspercore
            '''
            result = self._values.get("threads_per_core")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CpuOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.CreditSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"cpu_credits": "cpuCredits"},
    )
    class CreditSpecificationProperty:
        def __init__(
            self,
            *,
            cpu_credits: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the credit option for CPU usage of a T2, T3, or T3a instance.

            ``CreditSpecification`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param cpu_credits: The credit option for CPU usage of a T instance. Valid values: ``standard`` | ``unlimited``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-creditspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                credit_specification_property = ec2.CfnLaunchTemplate.CreditSpecificationProperty(
                    cpu_credits="cpuCredits"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__650ea292c25895ae31516c706d23275a66f0cceb4abe283b392b67c0f180be7d)
                check_type(argname="argument cpu_credits", value=cpu_credits, expected_type=type_hints["cpu_credits"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if cpu_credits is not None:
                self._values["cpu_credits"] = cpu_credits

        @builtins.property
        def cpu_credits(self) -> typing.Optional[builtins.str]:
            '''The credit option for CPU usage of a T instance.

            Valid values: ``standard`` | ``unlimited``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-creditspecification.html#cfn-ec2-launchtemplate-creditspecification-cpucredits
            '''
            result = self._values.get("cpu_credits")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CreditSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.EbsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "delete_on_termination": "deleteOnTermination",
            "encrypted": "encrypted",
            "iops": "iops",
            "kms_key_id": "kmsKeyId",
            "snapshot_id": "snapshotId",
            "throughput": "throughput",
            "volume_size": "volumeSize",
            "volume_type": "volumeType",
        },
    )
    class EbsProperty:
        def __init__(
            self,
            *,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            iops: typing.Optional[jsii.Number] = None,
            kms_key_id: typing.Optional[builtins.str] = None,
            snapshot_id: typing.Optional[builtins.str] = None,
            throughput: typing.Optional[jsii.Number] = None,
            volume_size: typing.Optional[jsii.Number] = None,
            volume_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Parameters for a block device for an EBS volume in an Amazon EC2 launch template.

            ``Ebs`` is a property of `AWS::EC2::LaunchTemplate BlockDeviceMapping <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-blockdevicemapping.html>`_ .

            :param delete_on_termination: Indicates whether the EBS volume is deleted on instance termination.
            :param encrypted: Indicates whether the EBS volume is encrypted. Encrypted volumes can only be attached to instances that support Amazon EBS encryption. If you are creating a volume from a snapshot, you can't specify an encryption value.
            :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000 - 16,000 IOPS - ``io1`` : 100 - 64,000 IOPS - ``io2`` : 100 - 256,000 IOPS For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS. This parameter is supported for ``io1`` , ``io2`` , and ``gp3`` volumes only.
            :param kms_key_id: The ARN of the symmetric AWS Key Management Service ( AWS KMS ) CMK used for encryption.
            :param snapshot_id: The ID of the snapshot.
            :param throughput: The throughput to provision for a ``gp3`` volume, with a maximum of 1,000 MiB/s. Valid Range: Minimum value of 125. Maximum value of 1000.
            :param volume_size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. The following are the supported volumes sizes for each volume type: - ``gp2`` and ``gp3`` : 1 - 16,384 GiB - ``io1`` : 4 - 16,384 GiB - ``io2`` : 4 - 65,536 GiB - ``st1`` and ``sc1`` : 125 - 16,384 GiB - ``standard`` : 1 - 1024 GiB
            :param volume_type: The volume type. For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ebs_property = ec2.CfnLaunchTemplate.EbsProperty(
                    delete_on_termination=False,
                    encrypted=False,
                    iops=123,
                    kms_key_id="kmsKeyId",
                    snapshot_id="snapshotId",
                    throughput=123,
                    volume_size=123,
                    volume_type="volumeType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__0c8f1bdc026599f0d5c31661061b4f7adf3cd9a673d2d6a32326ec212ec24087)
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
                check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
                check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
                check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
                check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
                check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
                check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if encrypted is not None:
                self._values["encrypted"] = encrypted
            if iops is not None:
                self._values["iops"] = iops
            if kms_key_id is not None:
                self._values["kms_key_id"] = kms_key_id
            if snapshot_id is not None:
                self._values["snapshot_id"] = snapshot_id
            if throughput is not None:
                self._values["throughput"] = throughput
            if volume_size is not None:
                self._values["volume_size"] = volume_size
            if volume_type is not None:
                self._values["volume_type"] = volume_type

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the EBS volume is deleted on instance termination.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def encrypted(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the EBS volume is encrypted.

            Encrypted volumes can only be attached to instances that support Amazon EBS encryption. If you are creating a volume from a snapshot, you can't specify an encryption value.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-encrypted
            '''
            result = self._values.get("encrypted")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def iops(self) -> typing.Optional[jsii.Number]:
            '''The number of I/O operations per second (IOPS).

            For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.

            The following are the supported values for each volume type:

            - ``gp3`` : 3,000 - 16,000 IOPS
            - ``io1`` : 100 - 64,000 IOPS
            - ``io2`` : 100 - 256,000 IOPS

            For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS.

            This parameter is supported for ``io1`` , ``io2`` , and ``gp3`` volumes only.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-iops
            '''
            result = self._values.get("iops")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def kms_key_id(self) -> typing.Optional[builtins.str]:
            '''The ARN of the symmetric AWS Key Management Service ( AWS KMS ) CMK used for encryption.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-kmskeyid
            '''
            result = self._values.get("kms_key_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def snapshot_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the snapshot.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-snapshotid
            '''
            result = self._values.get("snapshot_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def throughput(self) -> typing.Optional[jsii.Number]:
            '''The throughput to provision for a ``gp3`` volume, with a maximum of 1,000 MiB/s.

            Valid Range: Minimum value of 125. Maximum value of 1000.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-throughput
            '''
            result = self._values.get("throughput")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def volume_size(self) -> typing.Optional[jsii.Number]:
            '''The size of the volume, in GiBs.

            You must specify either a snapshot ID or a volume size. The following are the supported volumes sizes for each volume type:

            - ``gp2`` and ``gp3`` : 1 - 16,384 GiB
            - ``io1`` : 4 - 16,384 GiB
            - ``io2`` : 4 - 65,536 GiB
            - ``st1`` and ``sc1`` : 125 - 16,384 GiB
            - ``standard`` : 1 - 1024 GiB

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-volumesize
            '''
            result = self._values.get("volume_size")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def volume_type(self) -> typing.Optional[builtins.str]:
            '''The volume type.

            For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ebs.html#cfn-ec2-launchtemplate-ebs-volumetype
            '''
            result = self._values.get("volume_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EbsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.ElasticGpuSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"type": "type"},
    )
    class ElasticGpuSpecificationProperty:
        def __init__(self, *, type: typing.Optional[builtins.str] = None) -> None:
            '''.. epigraph::

   Amazon Elastic Graphics reached end of life on January 8, 2024.

            For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.

            Specifies a specification for an Elastic GPU for an Amazon EC2 launch template.

            ``ElasticGpuSpecification`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param type: The type of Elastic Graphics accelerator. For more information about the values to specify for ``Type`` , see `Elastic Graphics Basics <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html#elastic-graphics-basics>`_ , specifically the Elastic Graphics accelerator column, in the *Amazon Elastic Compute Cloud User Guide for Windows Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-elasticgpuspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                elastic_gpu_specification_property = ec2.CfnLaunchTemplate.ElasticGpuSpecificationProperty(
                    type="type"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__19b96e3009604a8e3574248d8fbff3f4c10a28af70ffc935c66f594c8f18f6a4)
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if type is not None:
                self._values["type"] = type

        @builtins.property
        def type(self) -> typing.Optional[builtins.str]:
            '''The type of Elastic Graphics accelerator.

            For more information about the values to specify for ``Type`` , see `Elastic Graphics Basics <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html#elastic-graphics-basics>`_ , specifically the Elastic Graphics accelerator column, in the *Amazon Elastic Compute Cloud User Guide for Windows Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-elasticgpuspecification.html#cfn-ec2-launchtemplate-elasticgpuspecification-type
            '''
            result = self._values.get("type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ElasticGpuSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.EnaSrdSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "ena_srd_enabled": "enaSrdEnabled",
            "ena_srd_udp_specification": "enaSrdUdpSpecification",
        },
    )
    class EnaSrdSpecificationProperty:
        def __init__(
            self,
            *,
            ena_srd_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            ena_srd_udp_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.EnaSrdUdpSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''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.

            :param ena_srd_enabled: Indicates whether ENA Express is enabled for the network interface.
            :param ena_srd_udp_specification: Configures ENA Express for UDP network traffic.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enasrdspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ena_srd_specification_property = ec2.CfnLaunchTemplate.EnaSrdSpecificationProperty(
                    ena_srd_enabled=False,
                    ena_srd_udp_specification=ec2.CfnLaunchTemplate.EnaSrdUdpSpecificationProperty(
                        ena_srd_udp_enabled=False
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1012f894773bff59813d4796c9ca396077aa7ac23f50a5a76d0e6942bb83b9fe)
                check_type(argname="argument ena_srd_enabled", value=ena_srd_enabled, expected_type=type_hints["ena_srd_enabled"])
                check_type(argname="argument ena_srd_udp_specification", value=ena_srd_udp_specification, expected_type=type_hints["ena_srd_udp_specification"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if ena_srd_enabled is not None:
                self._values["ena_srd_enabled"] = ena_srd_enabled
            if ena_srd_udp_specification is not None:
                self._values["ena_srd_udp_specification"] = ena_srd_udp_specification

        @builtins.property
        def ena_srd_enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether ENA Express is enabled for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enasrdspecification.html#cfn-ec2-launchtemplate-enasrdspecification-enasrdenabled
            '''
            result = self._values.get("ena_srd_enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def ena_srd_udp_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnaSrdUdpSpecificationProperty"]]:
            '''Configures ENA Express for UDP network traffic.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enasrdspecification.html#cfn-ec2-launchtemplate-enasrdspecification-enasrdudpspecification
            '''
            result = self._values.get("ena_srd_udp_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnaSrdUdpSpecificationProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EnaSrdSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.EnaSrdUdpSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"ena_srd_udp_enabled": "enaSrdUdpEnabled"},
    )
    class EnaSrdUdpSpecificationProperty:
        def __init__(
            self,
            *,
            ena_srd_udp_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''ENA Express is compatible with both TCP and UDP transport protocols.

            When it's enabled, TCP traffic automatically uses it. However, some UDP-based applications are designed to handle network packets that are out of order, without a need for retransmission, such as live video broadcasting or other near-real-time applications. For UDP traffic, you can specify whether to use ENA Express, based on your application environment needs.

            :param ena_srd_udp_enabled: Indicates whether UDP traffic to and from the instance uses ENA Express. To specify this setting, you must first enable ENA Express.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enasrdudpspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ena_srd_udp_specification_property = ec2.CfnLaunchTemplate.EnaSrdUdpSpecificationProperty(
                    ena_srd_udp_enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__aa25bf3d4882f0042cd7fb73d4474087952f2b030a49cb6ce8d8ba8e7f927072)
                check_type(argname="argument ena_srd_udp_enabled", value=ena_srd_udp_enabled, expected_type=type_hints["ena_srd_udp_enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if ena_srd_udp_enabled is not None:
                self._values["ena_srd_udp_enabled"] = ena_srd_udp_enabled

        @builtins.property
        def ena_srd_udp_enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether UDP traffic to and from the instance uses ENA Express.

            To specify this setting, you must first enable ENA Express.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enasrdudpspecification.html#cfn-ec2-launchtemplate-enasrdudpspecification-enasrdudpenabled
            '''
            result = self._values.get("ena_srd_udp_enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EnaSrdUdpSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.EnclaveOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled"},
    )
    class EnclaveOptionsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Indicates whether the instance is enabled for AWS Nitro Enclaves.

            :param enabled: If this parameter is set to ``true`` , the instance is enabled for AWS Nitro Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enclaveoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                enclave_options_property = ec2.CfnLaunchTemplate.EnclaveOptionsProperty(
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c36c5faceb0b39f4cd34426abd77f5b11c86067650f48eec6b4f48046bc4c53d)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''If this parameter is set to ``true`` , the instance is enabled for AWS Nitro Enclaves;

            otherwise, it is not enabled for AWS Nitro Enclaves.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-enclaveoptions.html#cfn-ec2-launchtemplate-enclaveoptions-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EnclaveOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.HibernationOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"configured": "configured"},
    )
    class HibernationOptionsProperty:
        def __init__(
            self,
            *,
            configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Specifies whether your instance is configured for hibernation.

            This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html#hibernating-prerequisites>`_ . For more information, see `Hibernate Your Instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon EC2 User Guide* .

            ``HibernationOptions`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param configured: If you set this parameter to ``true`` , the instance is enabled for hibernation. Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-hibernationoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                hibernation_options_property = ec2.CfnLaunchTemplate.HibernationOptionsProperty(
                    configured=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__327a2a24a5b6f3f507a60eca3b04ff8b5d76348f61ee6cc88f38868c95e02406)
                check_type(argname="argument configured", value=configured, expected_type=type_hints["configured"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if configured is not None:
                self._values["configured"] = configured

        @builtins.property
        def configured(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''If you set this parameter to ``true`` , the instance is enabled for hibernation.

            Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-hibernationoptions.html#cfn-ec2-launchtemplate-hibernationoptions-configured
            '''
            result = self._values.get("configured")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "HibernationOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.IamInstanceProfileProperty",
        jsii_struct_bases=[],
        name_mapping={"arn": "arn", "name": "name"},
    )
    class IamInstanceProfileProperty:
        def __init__(
            self,
            *,
            arn: typing.Optional[builtins.str] = None,
            name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies an IAM instance profile, which is a container for an IAM role for your instance.

            You can use an IAM role to distribute your AWS credentials to your instances.

            If you are creating the launch template for use with an Amazon EC2 Auto Scaling group, you can specify either the name or the ARN of the instance profile, but not both.

            ``IamInstanceProfile`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param arn: The Amazon Resource Name (ARN) of the instance profile.
            :param name: The name of the instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-iaminstanceprofile.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                iam_instance_profile_property = ec2.CfnLaunchTemplate.IamInstanceProfileProperty(
                    arn="arn",
                    name="name"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6c21fc9ed54da66fa9f6700f883d379212a08d0a227c1dd67618d1265d105f78)
                check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if arn is not None:
                self._values["arn"] = arn
            if name is not None:
                self._values["name"] = name

        @builtins.property
        def arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-iaminstanceprofile.html#cfn-ec2-launchtemplate-iaminstanceprofile-arn
            '''
            result = self._values.get("arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def name(self) -> typing.Optional[builtins.str]:
            '''The name of the instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-iaminstanceprofile.html#cfn-ec2-launchtemplate-iaminstanceprofile-name
            '''
            result = self._values.get("name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IamInstanceProfileProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.InstanceMarketOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"market_type": "marketType", "spot_options": "spotOptions"},
    )
    class InstanceMarketOptionsProperty:
        def __init__(
            self,
            *,
            market_type: typing.Optional[builtins.str] = None,
            spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.SpotOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies the market (purchasing) option for an instance.

            ``InstanceMarketOptions`` is a property of the `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param market_type: The market type.
            :param spot_options: The options for Spot Instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancemarketoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_market_options_property = ec2.CfnLaunchTemplate.InstanceMarketOptionsProperty(
                    market_type="marketType",
                    spot_options=ec2.CfnLaunchTemplate.SpotOptionsProperty(
                        block_duration_minutes=123,
                        instance_interruption_behavior="instanceInterruptionBehavior",
                        max_price="maxPrice",
                        spot_instance_type="spotInstanceType",
                        valid_until="validUntil"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__003d3ac8b5c132547bba40c1724b184411b92eac7e88c1091afeb7be99d1255a)
                check_type(argname="argument market_type", value=market_type, expected_type=type_hints["market_type"])
                check_type(argname="argument spot_options", value=spot_options, expected_type=type_hints["spot_options"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if market_type is not None:
                self._values["market_type"] = market_type
            if spot_options is not None:
                self._values["spot_options"] = spot_options

        @builtins.property
        def market_type(self) -> typing.Optional[builtins.str]:
            '''The market type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancemarketoptions.html#cfn-ec2-launchtemplate-instancemarketoptions-markettype
            '''
            result = self._values.get("market_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def spot_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.SpotOptionsProperty"]]:
            '''The options for Spot Instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancemarketoptions.html#cfn-ec2-launchtemplate-instancemarketoptions-spotoptions
            '''
            result = self._values.get("spot_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.SpotOptionsProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceMarketOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.InstanceRequirementsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "accelerator_count": "acceleratorCount",
            "accelerator_manufacturers": "acceleratorManufacturers",
            "accelerator_names": "acceleratorNames",
            "accelerator_total_memory_mib": "acceleratorTotalMemoryMiB",
            "accelerator_types": "acceleratorTypes",
            "allowed_instance_types": "allowedInstanceTypes",
            "bare_metal": "bareMetal",
            "baseline_ebs_bandwidth_mbps": "baselineEbsBandwidthMbps",
            "burstable_performance": "burstablePerformance",
            "cpu_manufacturers": "cpuManufacturers",
            "excluded_instance_types": "excludedInstanceTypes",
            "instance_generations": "instanceGenerations",
            "local_storage": "localStorage",
            "local_storage_types": "localStorageTypes",
            "max_spot_price_as_percentage_of_optimal_on_demand_price": "maxSpotPriceAsPercentageOfOptimalOnDemandPrice",
            "memory_gib_per_v_cpu": "memoryGiBPerVCpu",
            "memory_mib": "memoryMiB",
            "network_bandwidth_gbps": "networkBandwidthGbps",
            "network_interface_count": "networkInterfaceCount",
            "on_demand_max_price_percentage_over_lowest_price": "onDemandMaxPricePercentageOverLowestPrice",
            "require_hibernate_support": "requireHibernateSupport",
            "spot_max_price_percentage_over_lowest_price": "spotMaxPricePercentageOverLowestPrice",
            "total_local_storage_gb": "totalLocalStorageGb",
            "v_cpu_count": "vCpuCount",
        },
    )
    class InstanceRequirementsProperty:
        def __init__(
            self,
            *,
            accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.AcceleratorCountProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            bare_metal: typing.Optional[builtins.str] = None,
            baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            burstable_performance: typing.Optional[builtins.str] = None,
            cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
            local_storage: typing.Optional[builtins.str] = None,
            local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            max_spot_price_as_percentage_of_optimal_on_demand_price: typing.Optional[jsii.Number] = None,
            memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.MemoryGiBPerVCpuProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.MemoryMiBProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.NetworkBandwidthGbpsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.NetworkInterfaceCountProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.TotalLocalStorageGBProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.VCpuCountProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with these attributes.

            You must specify ``VCpuCount`` and ``MemoryMiB`` . All other attributes are optional. Any unspecified optional attribute is set to its default.

            When you specify multiple attributes, you get instance types that satisfy all of the specified attributes. If you specify multiple values for an attribute, you get instance types that satisfy any of the specified values.

            To limit the list of instance types from which Amazon EC2 can identify matching instance types, you can use one of the following parameters, but not both in the same request:

            - ``AllowedInstanceTypes`` - The instance types to include in the list. All other instance types are ignored, even if they match your specified attributes.
            - ``ExcludedInstanceTypes`` - The instance types to exclude from the list, even if they match your specified attributes.

            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

               Attribute-based instance type selection is only supported when using Auto Scaling groups, EC2 Fleet, and Spot Fleet to launch instances. If you plan to use the launch template in the `launch instance wizard <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html>`_ , or with the `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ API or `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ AWS CloudFormation resource, you can't specify ``InstanceRequirements`` .

            For more information, see `Attribute-based instance type selection for EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html>`_ , `Attribute-based instance type selection for Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html>`_ , and `Spot placement score <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html>`_ in the *Amazon EC2 User Guide* .

            :param accelerator_count: The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` . Default: No minimum or maximum limits
            :param accelerator_manufacturers: Indicates whether instance types must have accelerators by specific manufacturers. - For instance types with AWS devices, specify ``amazon-web-services`` . - For instance types with AMD devices, specify ``amd`` . - For instance types with Habana devices, specify ``habana`` . - For instance types with NVIDIA devices, specify ``nvidia`` . - For instance types with Xilinx devices, specify ``xilinx`` . Default: Any manufacturer
            :param accelerator_names: The accelerators that must be on the instance type. - For instance types with NVIDIA A10G GPUs, specify ``a10g`` . - For instance types with NVIDIA A100 GPUs, specify ``a100`` . - For instance types with NVIDIA H100 GPUs, specify ``h100`` . - For instance types with AWS Inferentia chips, specify ``inferentia`` . - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` . - For instance types with NVIDIA K80 GPUs, specify ``k80`` . - For instance types with NVIDIA M60 GPUs, specify ``m60`` . - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` . - For instance types with NVIDIA T4 GPUs, specify ``t4`` . - For instance types with NVIDIA T4G GPUs, specify ``t4g`` . - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` . - For instance types with NVIDIA V100 GPUs, specify ``v100`` . Default: Any accelerator
            :param accelerator_total_memory_mib: The minimum and maximum amount of total accelerator memory, in MiB. Default: No minimum or maximum limits
            :param accelerator_types: The accelerator types that must be on the instance type. - For instance types with GPU accelerators, specify ``gpu`` . - For instance types with FPGA accelerators, specify ``fpga`` . - For instance types with inference accelerators, specify ``inference`` . Default: Any accelerator type
            :param allowed_instance_types: The instance types to apply your specified attributes against. All other instance types are ignored, even if they match your specified attributes. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` . Default: All instance types
            :param bare_metal: Indicates whether bare metal instance types must be included, excluded, or required. - To include bare metal instance types, specify ``included`` . - To require only bare metal instance types, specify ``required`` . - To exclude bare metal instance types, specify ``excluded`` . Default: ``excluded``
            :param baseline_ebs_bandwidth_mbps: The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps. For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* . Default: No minimum or maximum limits
            :param burstable_performance: Indicates whether burstable performance T instance types are included, excluded, or required. For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ . - To include burstable performance instance types, specify ``included`` . - To require only burstable performance instance types, specify ``required`` . - To exclude burstable performance instance types, specify ``excluded`` . Default: ``excluded``
            :param cpu_manufacturers: The CPU manufacturers to include. - For instance types with Intel CPUs, specify ``intel`` . - For instance types with AMD CPUs, specify ``amd`` . - For instance types with AWS CPUs, specify ``amazon-web-services`` . .. epigraph:: Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template. Default: Any manufacturer
            :param excluded_instance_types: The instance types to exclude. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` . Default: No excluded instance types
            :param instance_generations: Indicates whether current or previous generation instance types are included. The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* . For current generation instance types, specify ``current`` . For previous generation instance types, specify ``previous`` . Default: Current and previous generation instance types
            :param local_storage: Indicates whether instance types with instance store volumes are included, excluded, or required. For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* . - To include instance types with instance store volumes, specify ``included`` . - To require only instance types with instance store volumes, specify ``required`` . - To exclude instance types with instance store volumes, specify ``excluded`` . Default: ``included``
            :param local_storage_types: The type of local storage that is required. - For instance types with hard disk drive (HDD) storage, specify ``hdd`` . - For instance types with solid state drive (SSD) storage, specify ``ssd`` . Default: ``hdd`` and ``ssd``
            :param max_spot_price_as_percentage_of_optimal_on_demand_price: [Price protection] The price protection threshold for Spot Instances, as a percentage of an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . If you set ``DesiredCapacityType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is based on the per vCPU or per memory price instead of the per instance price. .. epigraph:: Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` .
            :param memory_gib_per_v_cpu: The minimum and maximum amount of memory per vCPU, in GiB. Default: No minimum or maximum limits
            :param memory_mib: The minimum and maximum amount of memory, in MiB.
            :param network_bandwidth_gbps: The minimum and maximum amount of network bandwidth, in gigabits per second (Gbps). Default: No minimum or maximum limits
            :param network_interface_count: The minimum and maximum number of network interfaces. Default: No minimum or maximum limits
            :param on_demand_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To turn off price protection, specify a high value, such as ``999999`` . This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. Default: ``20``
            :param require_hibernate_support: Indicates whether instance types must support hibernation for On-Demand Instances. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ . Default: ``false``
            :param spot_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price. The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` . Default: ``100``
            :param total_local_storage_gb: The minimum and maximum amount of total local storage, in GB. Default: No minimum or maximum limits
            :param v_cpu_count: The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_requirements_property = ec2.CfnLaunchTemplate.InstanceRequirementsProperty(
                    accelerator_count=ec2.CfnLaunchTemplate.AcceleratorCountProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_manufacturers=["acceleratorManufacturers"],
                    accelerator_names=["acceleratorNames"],
                    accelerator_total_memory_mi_b=ec2.CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_types=["acceleratorTypes"],
                    allowed_instance_types=["allowedInstanceTypes"],
                    bare_metal="bareMetal",
                    baseline_ebs_bandwidth_mbps=ec2.CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty(
                        max=123,
                        min=123
                    ),
                    burstable_performance="burstablePerformance",
                    cpu_manufacturers=["cpuManufacturers"],
                    excluded_instance_types=["excludedInstanceTypes"],
                    instance_generations=["instanceGenerations"],
                    local_storage="localStorage",
                    local_storage_types=["localStorageTypes"],
                    max_spot_price_as_percentage_of_optimal_on_demand_price=123,
                    memory_gi_bPer_vCpu=ec2.CfnLaunchTemplate.MemoryGiBPerVCpuProperty(
                        max=123,
                        min=123
                    ),
                    memory_mi_b=ec2.CfnLaunchTemplate.MemoryMiBProperty(
                        max=123,
                        min=123
                    ),
                    network_bandwidth_gbps=ec2.CfnLaunchTemplate.NetworkBandwidthGbpsProperty(
                        max=123,
                        min=123
                    ),
                    network_interface_count=ec2.CfnLaunchTemplate.NetworkInterfaceCountProperty(
                        max=123,
                        min=123
                    ),
                    on_demand_max_price_percentage_over_lowest_price=123,
                    require_hibernate_support=False,
                    spot_max_price_percentage_over_lowest_price=123,
                    total_local_storage_gb=ec2.CfnLaunchTemplate.TotalLocalStorageGBProperty(
                        max=123,
                        min=123
                    ),
                    v_cpu_count=ec2.CfnLaunchTemplate.VCpuCountProperty(
                        max=123,
                        min=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__5fc9ef3203af5508d5ac30f48557352d8fd1abcefdc9c04e40826c7c68b41520)
                check_type(argname="argument accelerator_count", value=accelerator_count, expected_type=type_hints["accelerator_count"])
                check_type(argname="argument accelerator_manufacturers", value=accelerator_manufacturers, expected_type=type_hints["accelerator_manufacturers"])
                check_type(argname="argument accelerator_names", value=accelerator_names, expected_type=type_hints["accelerator_names"])
                check_type(argname="argument accelerator_total_memory_mib", value=accelerator_total_memory_mib, expected_type=type_hints["accelerator_total_memory_mib"])
                check_type(argname="argument accelerator_types", value=accelerator_types, expected_type=type_hints["accelerator_types"])
                check_type(argname="argument allowed_instance_types", value=allowed_instance_types, expected_type=type_hints["allowed_instance_types"])
                check_type(argname="argument bare_metal", value=bare_metal, expected_type=type_hints["bare_metal"])
                check_type(argname="argument baseline_ebs_bandwidth_mbps", value=baseline_ebs_bandwidth_mbps, expected_type=type_hints["baseline_ebs_bandwidth_mbps"])
                check_type(argname="argument burstable_performance", value=burstable_performance, expected_type=type_hints["burstable_performance"])
                check_type(argname="argument cpu_manufacturers", value=cpu_manufacturers, expected_type=type_hints["cpu_manufacturers"])
                check_type(argname="argument excluded_instance_types", value=excluded_instance_types, expected_type=type_hints["excluded_instance_types"])
                check_type(argname="argument instance_generations", value=instance_generations, expected_type=type_hints["instance_generations"])
                check_type(argname="argument local_storage", value=local_storage, expected_type=type_hints["local_storage"])
                check_type(argname="argument local_storage_types", value=local_storage_types, expected_type=type_hints["local_storage_types"])
                check_type(argname="argument max_spot_price_as_percentage_of_optimal_on_demand_price", value=max_spot_price_as_percentage_of_optimal_on_demand_price, expected_type=type_hints["max_spot_price_as_percentage_of_optimal_on_demand_price"])
                check_type(argname="argument memory_gib_per_v_cpu", value=memory_gib_per_v_cpu, expected_type=type_hints["memory_gib_per_v_cpu"])
                check_type(argname="argument memory_mib", value=memory_mib, expected_type=type_hints["memory_mib"])
                check_type(argname="argument network_bandwidth_gbps", value=network_bandwidth_gbps, expected_type=type_hints["network_bandwidth_gbps"])
                check_type(argname="argument network_interface_count", value=network_interface_count, expected_type=type_hints["network_interface_count"])
                check_type(argname="argument on_demand_max_price_percentage_over_lowest_price", value=on_demand_max_price_percentage_over_lowest_price, expected_type=type_hints["on_demand_max_price_percentage_over_lowest_price"])
                check_type(argname="argument require_hibernate_support", value=require_hibernate_support, expected_type=type_hints["require_hibernate_support"])
                check_type(argname="argument spot_max_price_percentage_over_lowest_price", value=spot_max_price_percentage_over_lowest_price, expected_type=type_hints["spot_max_price_percentage_over_lowest_price"])
                check_type(argname="argument total_local_storage_gb", value=total_local_storage_gb, expected_type=type_hints["total_local_storage_gb"])
                check_type(argname="argument v_cpu_count", value=v_cpu_count, expected_type=type_hints["v_cpu_count"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if accelerator_count is not None:
                self._values["accelerator_count"] = accelerator_count
            if accelerator_manufacturers is not None:
                self._values["accelerator_manufacturers"] = accelerator_manufacturers
            if accelerator_names is not None:
                self._values["accelerator_names"] = accelerator_names
            if accelerator_total_memory_mib is not None:
                self._values["accelerator_total_memory_mib"] = accelerator_total_memory_mib
            if accelerator_types is not None:
                self._values["accelerator_types"] = accelerator_types
            if allowed_instance_types is not None:
                self._values["allowed_instance_types"] = allowed_instance_types
            if bare_metal is not None:
                self._values["bare_metal"] = bare_metal
            if baseline_ebs_bandwidth_mbps is not None:
                self._values["baseline_ebs_bandwidth_mbps"] = baseline_ebs_bandwidth_mbps
            if burstable_performance is not None:
                self._values["burstable_performance"] = burstable_performance
            if cpu_manufacturers is not None:
                self._values["cpu_manufacturers"] = cpu_manufacturers
            if excluded_instance_types is not None:
                self._values["excluded_instance_types"] = excluded_instance_types
            if instance_generations is not None:
                self._values["instance_generations"] = instance_generations
            if local_storage is not None:
                self._values["local_storage"] = local_storage
            if local_storage_types is not None:
                self._values["local_storage_types"] = local_storage_types
            if max_spot_price_as_percentage_of_optimal_on_demand_price is not None:
                self._values["max_spot_price_as_percentage_of_optimal_on_demand_price"] = max_spot_price_as_percentage_of_optimal_on_demand_price
            if memory_gib_per_v_cpu is not None:
                self._values["memory_gib_per_v_cpu"] = memory_gib_per_v_cpu
            if memory_mib is not None:
                self._values["memory_mib"] = memory_mib
            if network_bandwidth_gbps is not None:
                self._values["network_bandwidth_gbps"] = network_bandwidth_gbps
            if network_interface_count is not None:
                self._values["network_interface_count"] = network_interface_count
            if on_demand_max_price_percentage_over_lowest_price is not None:
                self._values["on_demand_max_price_percentage_over_lowest_price"] = on_demand_max_price_percentage_over_lowest_price
            if require_hibernate_support is not None:
                self._values["require_hibernate_support"] = require_hibernate_support
            if spot_max_price_percentage_over_lowest_price is not None:
                self._values["spot_max_price_percentage_over_lowest_price"] = spot_max_price_percentage_over_lowest_price
            if total_local_storage_gb is not None:
                self._values["total_local_storage_gb"] = total_local_storage_gb
            if v_cpu_count is not None:
                self._values["v_cpu_count"] = v_cpu_count

        @builtins.property
        def accelerator_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.AcceleratorCountProperty"]]:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-acceleratorcount
            '''
            result = self._values.get("accelerator_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.AcceleratorCountProperty"]], result)

        @builtins.property
        def accelerator_manufacturers(
            self,
        ) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether instance types must have accelerators by specific manufacturers.

            - For instance types with AWS devices, specify ``amazon-web-services`` .
            - For instance types with AMD devices, specify ``amd`` .
            - For instance types with Habana devices, specify ``habana`` .
            - For instance types with NVIDIA devices, specify ``nvidia`` .
            - For instance types with Xilinx devices, specify ``xilinx`` .

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-acceleratormanufacturers
            '''
            result = self._values.get("accelerator_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_names(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerators that must be on the instance type.

            - For instance types with NVIDIA A10G GPUs, specify ``a10g`` .
            - For instance types with NVIDIA A100 GPUs, specify ``a100`` .
            - For instance types with NVIDIA H100 GPUs, specify ``h100`` .
            - For instance types with AWS Inferentia chips, specify ``inferentia`` .
            - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` .
            - For instance types with NVIDIA K80 GPUs, specify ``k80`` .
            - For instance types with NVIDIA M60 GPUs, specify ``m60`` .
            - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` .
            - For instance types with NVIDIA T4 GPUs, specify ``t4`` .
            - For instance types with NVIDIA T4G GPUs, specify ``t4g`` .
            - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` .
            - For instance types with NVIDIA V100 GPUs, specify ``v100`` .

            Default: Any accelerator

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-acceleratornames
            '''
            result = self._values.get("accelerator_names")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_total_memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty"]]:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-acceleratortotalmemorymib
            '''
            result = self._values.get("accelerator_total_memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty"]], result)

        @builtins.property
        def accelerator_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerator types that must be on the instance type.

            - For instance types with GPU accelerators, specify ``gpu`` .
            - For instance types with FPGA accelerators, specify ``fpga`` .
            - For instance types with inference accelerators, specify ``inference`` .

            Default: Any accelerator type

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-acceleratortypes
            '''
            result = self._values.get("accelerator_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def allowed_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to apply your specified attributes against.

            All other instance types are ignored, even if they match your specified attributes.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` .

            Default: All instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-allowedinstancetypes
            '''
            result = self._values.get("allowed_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def bare_metal(self) -> typing.Optional[builtins.str]:
            '''Indicates whether bare metal instance types must be included, excluded, or required.

            - To include bare metal instance types, specify ``included`` .
            - To require only bare metal instance types, specify ``required`` .
            - To exclude bare metal instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-baremetal
            '''
            result = self._values.get("bare_metal")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def baseline_ebs_bandwidth_mbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty"]]:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-baselineebsbandwidthmbps
            '''
            result = self._values.get("baseline_ebs_bandwidth_mbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty"]], result)

        @builtins.property
        def burstable_performance(self) -> typing.Optional[builtins.str]:
            '''Indicates whether burstable performance T instance types are included, excluded, or required.

            For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ .

            - To include burstable performance instance types, specify ``included`` .
            - To require only burstable performance instance types, specify ``required`` .
            - To exclude burstable performance instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-burstableperformance
            '''
            result = self._values.get("burstable_performance")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cpu_manufacturers(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The CPU manufacturers to include.

            - For instance types with Intel CPUs, specify ``intel`` .
            - For instance types with AMD CPUs, specify ``amd`` .
            - For instance types with AWS CPUs, specify ``amazon-web-services`` .

            .. epigraph::

               Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template.

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-cpumanufacturers
            '''
            result = self._values.get("cpu_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def excluded_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to exclude.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` .

            Default: No excluded instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-excludedinstancetypes
            '''
            result = self._values.get("excluded_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def instance_generations(self) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether current or previous generation instance types are included.

            The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .

            For current generation instance types, specify ``current`` .

            For previous generation instance types, specify ``previous`` .

            Default: Current and previous generation instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-instancegenerations
            '''
            result = self._values.get("instance_generations")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def local_storage(self) -> typing.Optional[builtins.str]:
            '''Indicates whether instance types with instance store volumes are included, excluded, or required.

            For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* .

            - To include instance types with instance store volumes, specify ``included`` .
            - To require only instance types with instance store volumes, specify ``required`` .
            - To exclude instance types with instance store volumes, specify ``excluded`` .

            Default: ``included``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-localstorage
            '''
            result = self._values.get("local_storage")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def local_storage_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The type of local storage that is required.

            - For instance types with hard disk drive (HDD) storage, specify ``hdd`` .
            - For instance types with solid state drive (SSD) storage, specify ``ssd`` .

            Default: ``hdd`` and ``ssd``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-localstoragetypes
            '''
            result = self._values.get("local_storage_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def max_spot_price_as_percentage_of_optimal_on_demand_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for Spot Instances, as a percentage of an identified On-Demand price.

            The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            If you set ``DesiredCapacityType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is based on the per vCPU or per memory price instead of the per instance price.
            .. epigraph::

               Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-maxspotpriceaspercentageofoptimalondemandprice
            '''
            result = self._values.get("max_spot_price_as_percentage_of_optimal_on_demand_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def memory_gib_per_v_cpu(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MemoryGiBPerVCpuProperty"]]:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-memorygibpervcpu
            '''
            result = self._values.get("memory_gib_per_v_cpu")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MemoryGiBPerVCpuProperty"]], result)

        @builtins.property
        def memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MemoryMiBProperty"]]:
            '''The minimum and maximum amount of memory, in MiB.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-memorymib
            '''
            result = self._values.get("memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MemoryMiBProperty"]], result)

        @builtins.property
        def network_bandwidth_gbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkBandwidthGbpsProperty"]]:
            '''The minimum and maximum amount of network bandwidth, in gigabits per second (Gbps).

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-networkbandwidthgbps
            '''
            result = self._values.get("network_bandwidth_gbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkBandwidthGbpsProperty"]], result)

        @builtins.property
        def network_interface_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkInterfaceCountProperty"]]:
            '''The minimum and maximum number of network interfaces.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-networkinterfacecount
            '''
            result = self._values.get("network_interface_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkInterfaceCountProperty"]], result)

        @builtins.property
        def on_demand_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price.

            The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To turn off price protection, specify a high value, such as ``999999`` .

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            Default: ``20``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-ondemandmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("on_demand_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def require_hibernate_support(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether instance types must support hibernation for On-Demand Instances.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ .

            Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-requirehibernatesupport
            '''
            result = self._values.get("require_hibernate_support")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def spot_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price.

            The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` .

            Default: ``100``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-spotmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("spot_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def total_local_storage_gb(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.TotalLocalStorageGBProperty"]]:
            '''The minimum and maximum amount of total local storage, in GB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-totallocalstoragegb
            '''
            result = self._values.get("total_local_storage_gb")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.TotalLocalStorageGBProperty"]], result)

        @builtins.property
        def v_cpu_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.VCpuCountProperty"]]:
            '''The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-instancerequirements.html#cfn-ec2-launchtemplate-instancerequirements-vcpucount
            '''
            result = self._values.get("v_cpu_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.VCpuCountProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceRequirementsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.Ipv4PrefixSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv4_prefix": "ipv4Prefix"},
    )
    class Ipv4PrefixSpecificationProperty:
        def __init__(
            self,
            *,
            ipv4_prefix: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies an IPv4 prefix for a network interface.

            ``Ipv4PrefixSpecification`` is a property of `AWS::EC2::LaunchTemplate NetworkInterface <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html>`_ .

            :param ipv4_prefix: The IPv4 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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv4prefixspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipv4_prefix_specification_property = ec2.CfnLaunchTemplate.Ipv4PrefixSpecificationProperty(
                    ipv4_prefix="ipv4Prefix"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__3cfe8961eadb8bc57f35326a6ee53739d3a1d2f2f5a2330d9c6564f4ce7d1f71)
                check_type(argname="argument ipv4_prefix", value=ipv4_prefix, expected_type=type_hints["ipv4_prefix"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if ipv4_prefix is not None:
                self._values["ipv4_prefix"] = ipv4_prefix

        @builtins.property
        def ipv4_prefix(self) -> typing.Optional[builtins.str]:
            '''The IPv4 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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv4prefixspecification.html#cfn-ec2-launchtemplate-ipv4prefixspecification-ipv4prefix
            '''
            result = self._values.get("ipv4_prefix")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "Ipv4PrefixSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.Ipv6AddProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_address": "ipv6Address"},
    )
    class Ipv6AddProperty:
        def __init__(
            self,
            *,
            ipv6_address: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies an IPv6 address in an Amazon EC2 launch template.

            ``Ipv6Add`` is a property of `AWS::EC2::LaunchTemplate NetworkInterface <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html>`_ .

            :param ipv6_address: One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet. You can't use this option if you're specifying a number of IPv6 addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv6add.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipv6_add_property = ec2.CfnLaunchTemplate.Ipv6AddProperty(
                    ipv6_address="ipv6Address"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__618292bbecfe7667a58541f030f774652abb4b04ec4cf699350c70493cb512e1)
                check_type(argname="argument ipv6_address", value=ipv6_address, expected_type=type_hints["ipv6_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if ipv6_address is not None:
                self._values["ipv6_address"] = ipv6_address

        @builtins.property
        def ipv6_address(self) -> typing.Optional[builtins.str]:
            '''One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet.

            You can't use this option if you're specifying a number of IPv6 addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv6add.html#cfn-ec2-launchtemplate-ipv6add-ipv6address
            '''
            result = self._values.get("ipv6_address")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "Ipv6AddProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.Ipv6PrefixSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_prefix": "ipv6Prefix"},
    )
    class Ipv6PrefixSpecificationProperty:
        def __init__(
            self,
            *,
            ipv6_prefix: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies an IPv6 prefix for a network interface.

            ``Ipv6PrefixSpecification`` is a property of `AWS::EC2::LaunchTemplate NetworkInterface <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html>`_ .

            :param ipv6_prefix: The IPv6 prefix.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv6prefixspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipv6_prefix_specification_property = ec2.CfnLaunchTemplate.Ipv6PrefixSpecificationProperty(
                    ipv6_prefix="ipv6Prefix"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1c01009dab469362d3432a6c66578fd0cc3f09d9c8cbadfb6bfef1866252c833)
                check_type(argname="argument ipv6_prefix", value=ipv6_prefix, expected_type=type_hints["ipv6_prefix"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if ipv6_prefix is not None:
                self._values["ipv6_prefix"] = ipv6_prefix

        @builtins.property
        def ipv6_prefix(self) -> typing.Optional[builtins.str]:
            '''The IPv6 prefix.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-ipv6prefixspecification.html#cfn-ec2-launchtemplate-ipv6prefixspecification-ipv6prefix
            '''
            result = self._values.get("ipv6_prefix")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "Ipv6PrefixSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.LaunchTemplateDataProperty",
        jsii_struct_bases=[],
        name_mapping={
            "block_device_mappings": "blockDeviceMappings",
            "capacity_reservation_specification": "capacityReservationSpecification",
            "cpu_options": "cpuOptions",
            "credit_specification": "creditSpecification",
            "disable_api_stop": "disableApiStop",
            "disable_api_termination": "disableApiTermination",
            "ebs_optimized": "ebsOptimized",
            "elastic_gpu_specifications": "elasticGpuSpecifications",
            "elastic_inference_accelerators": "elasticInferenceAccelerators",
            "enclave_options": "enclaveOptions",
            "hibernation_options": "hibernationOptions",
            "iam_instance_profile": "iamInstanceProfile",
            "image_id": "imageId",
            "instance_initiated_shutdown_behavior": "instanceInitiatedShutdownBehavior",
            "instance_market_options": "instanceMarketOptions",
            "instance_requirements": "instanceRequirements",
            "instance_type": "instanceType",
            "kernel_id": "kernelId",
            "key_name": "keyName",
            "license_specifications": "licenseSpecifications",
            "maintenance_options": "maintenanceOptions",
            "metadata_options": "metadataOptions",
            "monitoring": "monitoring",
            "network_interfaces": "networkInterfaces",
            "placement": "placement",
            "private_dns_name_options": "privateDnsNameOptions",
            "ram_disk_id": "ramDiskId",
            "security_group_ids": "securityGroupIds",
            "security_groups": "securityGroups",
            "tag_specifications": "tagSpecifications",
            "user_data": "userData",
        },
    )
    class LaunchTemplateDataProperty:
        def __init__(
            self,
            *,
            block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.BlockDeviceMappingProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            capacity_reservation_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.CapacityReservationSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.CpuOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.CreditSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            disable_api_stop: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.ElasticGpuSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.EnclaveOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.HibernationOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            iam_instance_profile: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.IamInstanceProfileProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            image_id: typing.Optional[builtins.str] = None,
            instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
            instance_market_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.InstanceMarketOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.InstanceRequirementsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_type: typing.Optional[builtins.str] = None,
            kernel_id: typing.Optional[builtins.str] = None,
            key_name: typing.Optional[builtins.str] = None,
            license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.LicenseSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            maintenance_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.MaintenanceOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            metadata_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.MetadataOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            monitoring: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.MonitoringProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.NetworkInterfaceProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.PlacementProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.PrivateDnsNameOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            ram_disk_id: typing.Optional[builtins.str] = None,
            security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
            security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
            tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.TagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            user_data: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The information to include in the launch template.

            .. epigraph::

               You must specify at least one parameter for the launch template data.

            :param block_device_mappings: The block device mapping.
            :param capacity_reservation_specification: The Capacity Reservation targeting option. If you do not specify this parameter, the instance's Capacity Reservation preference defaults to ``open`` , which enables it to run in any open Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).
            :param cpu_options: The CPU options for the instance. For more information, see `Optimizing CPU Options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param credit_specification: The credit option for CPU usage of the instance. Valid only for T instances.
            :param disable_api_stop: Indicates whether to enable the instance for stop protection. For more information, see `Stop protection <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html#Using_StopProtection>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param disable_api_termination: If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can. To change this attribute after launch, use `ModifyInstanceAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html>`_ . Alternatively, if you set ``InstanceInitiatedShutdownBehavior`` to ``terminate`` , you can terminate the instance by running the shutdown command from the instance.
            :param ebs_optimized: Indicates whether the instance is optimized for Amazon EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance.
            :param elastic_gpu_specifications: Deprecated. .. epigraph:: Amazon Elastic Graphics reached end of life on January 8, 2024. For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.
            :param elastic_inference_accelerators: An elastic inference accelerator to associate with the instance. Elastic inference accelerators are a resource you can attach to your Amazon EC2 instances to accelerate your Deep Learning (DL) inference workloads. You cannot specify accelerators from different generations in the same request. .. epigraph:: Starting April 15, 2023, AWS will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, Amazon ECS, or Amazon EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.
            :param enclave_options: Indicates whether the instance is enabled for AWS Nitro Enclaves. For more information, see `What is AWS Nitro Enclaves? <https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave.html>`_ in the *AWS Nitro Enclaves User Guide* . You can't enable AWS Nitro Enclaves and hibernation on the same instance.
            :param hibernation_options: Indicates whether an instance is enabled for hibernation. This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html>`_ . For more information, see `Hibernate your instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param iam_instance_profile: The name or Amazon Resource Name (ARN) of an IAM instance profile.
            :param image_id: The ID of the AMI. Alternatively, you can specify a Systems Manager parameter, which will resolve to an AMI ID on launch. Valid formats: - ``ami-17characters00000`` - ``resolve:ssm:parameter-name`` - ``resolve:ssm:parameter-name:version-number`` - ``resolve:ssm:parameter-name:label`` For more information, see `Use a Systems Manager parameter to find an AMI <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html#using-systems-manager-parameter-to-find-AMI>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param instance_initiated_shutdown_behavior: Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Default: ``stop``
            :param instance_market_options: The market (purchasing) option for the instances.
            :param instance_requirements: The attributes for the instance types. When you specify instance attributes, Amazon EC2 will identify instance types with these attributes. You must specify ``VCpuCount`` and ``MemoryMiB`` . All other attributes are optional. Any unspecified optional attribute is set to its default. When you specify multiple attributes, you get instance types that satisfy all of the specified attributes. If you specify multiple values for an attribute, you get instance types that satisfy any of the specified values. To limit the list of instance types from which Amazon EC2 can identify matching instance types, you can use one of the following parameters, but not both in the same request: - ``AllowedInstanceTypes`` - The instance types to include in the list. All other instance types are ignored, even if they match your specified attributes. - ``ExcludedInstanceTypes`` - The instance types to exclude from the list, even if they match your specified attributes. .. epigraph:: If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` . Attribute-based instance type selection is only supported when using Auto Scaling groups, EC2 Fleet, and Spot Fleet to launch instances. If you plan to use the launch template in the `launch instance wizard <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html>`_ , or with the `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ API or `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ AWS CloudFormation resource, you can't specify ``InstanceRequirements`` . For more information, see `Attribute-based instance type selection for EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html>`_ , `Attribute-based instance type selection for Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html>`_ , and `Spot placement score <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html>`_ in the *Amazon EC2 User Guide* .
            :param instance_type: The instance type. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . If you specify ``InstanceType`` , you can't specify ``InstanceRequirements`` .
            :param kernel_id: The ID of the kernel. We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `User Provided Kernels <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .
            :param key_name: The name of the key pair. You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ . .. epigraph:: If you do not specify a key pair, you can't connect to the instance unless you choose an AMI that is configured to allow users another way to log in.
            :param license_specifications: The license configurations.
            :param maintenance_options: The maintenance options of your instance.
            :param metadata_options: The metadata options for the instance. For more information, see `Instance metadata and user data <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param monitoring: The monitoring for the instance.
            :param network_interfaces: One or more network interfaces. If you specify a network interface, you must specify any security groups and subnets as part of the network interface.
            :param placement: The placement for the instance.
            :param private_dns_name_options: The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries should be handled. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param ram_disk_id: The ID of the RAM disk. .. epigraph:: We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `User provided kernels <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .
            :param security_group_ids: The IDs of the security groups. You can specify the IDs of existing security groups and references to resources created by the stack template.
            :param security_groups: One or more security group names. For a nondefault VPC, you must use security group IDs instead.
            :param tag_specifications: The tags to apply to the resources that are created during instance launch. To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ . To tag the launch template itself, use `TagSpecifications <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications>`_ .
            :param user_data: The user data to make available to the instance. You must provide base64-encoded text. User data is limited to 16 KB. For more information, see `Run commands on your Linux instance at launch <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html>`_ (Linux) or `Work with instance user data <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/instancedata-add-user-data.html>`_ (Windows) in the *Amazon Elastic Compute Cloud User Guide* . If you are creating the launch template for use with AWS Batch , the user data must be provided in the `MIME multi-part archive format <https://docs.aws.amazon.com/https://cloudinit.readthedocs.io/en/latest/topics/format.html#mime-multi-part-archive>`_ . For more information, see `Amazon EC2 user data in launch templates <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html>`_ in the *AWS Batch User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_data_property = ec2.CfnLaunchTemplate.LaunchTemplateDataProperty(
                    block_device_mappings=[ec2.CfnLaunchTemplate.BlockDeviceMappingProperty(
                        device_name="deviceName",
                        ebs=ec2.CfnLaunchTemplate.EbsProperty(
                            delete_on_termination=False,
                            encrypted=False,
                            iops=123,
                            kms_key_id="kmsKeyId",
                            snapshot_id="snapshotId",
                            throughput=123,
                            volume_size=123,
                            volume_type="volumeType"
                        ),
                        no_device="noDevice",
                        virtual_name="virtualName"
                    )],
                    capacity_reservation_specification=ec2.CfnLaunchTemplate.CapacityReservationSpecificationProperty(
                        capacity_reservation_preference="capacityReservationPreference",
                        capacity_reservation_target=ec2.CfnLaunchTemplate.CapacityReservationTargetProperty(
                            capacity_reservation_id="capacityReservationId",
                            capacity_reservation_resource_group_arn="capacityReservationResourceGroupArn"
                        )
                    ),
                    cpu_options=ec2.CfnLaunchTemplate.CpuOptionsProperty(
                        amd_sev_snp="amdSevSnp",
                        core_count=123,
                        threads_per_core=123
                    ),
                    credit_specification=ec2.CfnLaunchTemplate.CreditSpecificationProperty(
                        cpu_credits="cpuCredits"
                    ),
                    disable_api_stop=False,
                    disable_api_termination=False,
                    ebs_optimized=False,
                    elastic_gpu_specifications=[ec2.CfnLaunchTemplate.ElasticGpuSpecificationProperty(
                        type="type"
                    )],
                    elastic_inference_accelerators=[ec2.CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty(
                        count=123,
                        type="type"
                    )],
                    enclave_options=ec2.CfnLaunchTemplate.EnclaveOptionsProperty(
                        enabled=False
                    ),
                    hibernation_options=ec2.CfnLaunchTemplate.HibernationOptionsProperty(
                        configured=False
                    ),
                    iam_instance_profile=ec2.CfnLaunchTemplate.IamInstanceProfileProperty(
                        arn="arn",
                        name="name"
                    ),
                    image_id="imageId",
                    instance_initiated_shutdown_behavior="instanceInitiatedShutdownBehavior",
                    instance_market_options=ec2.CfnLaunchTemplate.InstanceMarketOptionsProperty(
                        market_type="marketType",
                        spot_options=ec2.CfnLaunchTemplate.SpotOptionsProperty(
                            block_duration_minutes=123,
                            instance_interruption_behavior="instanceInterruptionBehavior",
                            max_price="maxPrice",
                            spot_instance_type="spotInstanceType",
                            valid_until="validUntil"
                        )
                    ),
                    instance_requirements=ec2.CfnLaunchTemplate.InstanceRequirementsProperty(
                        accelerator_count=ec2.CfnLaunchTemplate.AcceleratorCountProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        max_spot_price_as_percentage_of_optimal_on_demand_price=123,
                        memory_gi_bPer_vCpu=ec2.CfnLaunchTemplate.MemoryGiBPerVCpuProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnLaunchTemplate.MemoryMiBProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnLaunchTemplate.NetworkBandwidthGbpsProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnLaunchTemplate.NetworkInterfaceCountProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnLaunchTemplate.TotalLocalStorageGBProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnLaunchTemplate.VCpuCountProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    kernel_id="kernelId",
                    key_name="keyName",
                    license_specifications=[ec2.CfnLaunchTemplate.LicenseSpecificationProperty(
                        license_configuration_arn="licenseConfigurationArn"
                    )],
                    maintenance_options=ec2.CfnLaunchTemplate.MaintenanceOptionsProperty(
                        auto_recovery="autoRecovery",
                        reboot_migration="rebootMigration"
                    ),
                    metadata_options=ec2.CfnLaunchTemplate.MetadataOptionsProperty(
                        http_endpoint="httpEndpoint",
                        http_protocol_ipv6="httpProtocolIpv6",
                        http_put_response_hop_limit=123,
                        http_tokens="httpTokens",
                        instance_metadata_tags="instanceMetadataTags"
                    ),
                    monitoring=ec2.CfnLaunchTemplate.MonitoringProperty(
                        enabled=False
                    ),
                    network_interfaces=[ec2.CfnLaunchTemplate.NetworkInterfaceProperty(
                        associate_carrier_ip_address=False,
                        associate_public_ip_address=False,
                        connection_tracking_specification=ec2.CfnLaunchTemplate.ConnectionTrackingSpecificationProperty(
                            tcp_established_timeout=123,
                            udp_stream_timeout=123,
                            udp_timeout=123
                        ),
                        delete_on_termination=False,
                        description="description",
                        device_index=123,
                        ena_srd_specification=ec2.CfnLaunchTemplate.EnaSrdSpecificationProperty(
                            ena_srd_enabled=False,
                            ena_srd_udp_specification=ec2.CfnLaunchTemplate.EnaSrdUdpSpecificationProperty(
                                ena_srd_udp_enabled=False
                            )
                        ),
                        groups=["groups"],
                        interface_type="interfaceType",
                        ipv4_prefix_count=123,
                        ipv4_prefixes=[ec2.CfnLaunchTemplate.Ipv4PrefixSpecificationProperty(
                            ipv4_prefix="ipv4Prefix"
                        )],
                        ipv6_address_count=123,
                        ipv6_addresses=[ec2.CfnLaunchTemplate.Ipv6AddProperty(
                            ipv6_address="ipv6Address"
                        )],
                        ipv6_prefix_count=123,
                        ipv6_prefixes=[ec2.CfnLaunchTemplate.Ipv6PrefixSpecificationProperty(
                            ipv6_prefix="ipv6Prefix"
                        )],
                        network_card_index=123,
                        network_interface_id="networkInterfaceId",
                        primary_ipv6=False,
                        private_ip_address="privateIpAddress",
                        private_ip_addresses=[ec2.CfnLaunchTemplate.PrivateIpAddProperty(
                            primary=False,
                            private_ip_address="privateIpAddress"
                        )],
                        secondary_private_ip_address_count=123,
                        subnet_id="subnetId"
                    )],
                    placement=ec2.CfnLaunchTemplate.PlacementProperty(
                        affinity="affinity",
                        availability_zone="availabilityZone",
                        group_id="groupId",
                        group_name="groupName",
                        host_id="hostId",
                        host_resource_group_arn="hostResourceGroupArn",
                        partition_number=123,
                        spread_domain="spreadDomain",
                        tenancy="tenancy"
                    ),
                    private_dns_name_options=ec2.CfnLaunchTemplate.PrivateDnsNameOptionsProperty(
                        enable_resource_name_dns_aaaa_record=False,
                        enable_resource_name_dns_aRecord=False,
                        hostname_type="hostnameType"
                    ),
                    ram_disk_id="ramDiskId",
                    security_group_ids=["securityGroupIds"],
                    security_groups=["securityGroups"],
                    tag_specifications=[ec2.CfnLaunchTemplate.TagSpecificationProperty(
                        resource_type="resourceType",
                        tags=[CfnTag(
                            key="key",
                            value="value"
                        )]
                    )],
                    user_data="userData"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__32e451f142fe00b3c107b71085c6014d26afe5f783aa89348cda122b9cc43ea9)
                check_type(argname="argument block_device_mappings", value=block_device_mappings, expected_type=type_hints["block_device_mappings"])
                check_type(argname="argument capacity_reservation_specification", value=capacity_reservation_specification, expected_type=type_hints["capacity_reservation_specification"])
                check_type(argname="argument cpu_options", value=cpu_options, expected_type=type_hints["cpu_options"])
                check_type(argname="argument credit_specification", value=credit_specification, expected_type=type_hints["credit_specification"])
                check_type(argname="argument disable_api_stop", value=disable_api_stop, expected_type=type_hints["disable_api_stop"])
                check_type(argname="argument disable_api_termination", value=disable_api_termination, expected_type=type_hints["disable_api_termination"])
                check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
                check_type(argname="argument elastic_gpu_specifications", value=elastic_gpu_specifications, expected_type=type_hints["elastic_gpu_specifications"])
                check_type(argname="argument elastic_inference_accelerators", value=elastic_inference_accelerators, expected_type=type_hints["elastic_inference_accelerators"])
                check_type(argname="argument enclave_options", value=enclave_options, expected_type=type_hints["enclave_options"])
                check_type(argname="argument hibernation_options", value=hibernation_options, expected_type=type_hints["hibernation_options"])
                check_type(argname="argument iam_instance_profile", value=iam_instance_profile, expected_type=type_hints["iam_instance_profile"])
                check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
                check_type(argname="argument instance_initiated_shutdown_behavior", value=instance_initiated_shutdown_behavior, expected_type=type_hints["instance_initiated_shutdown_behavior"])
                check_type(argname="argument instance_market_options", value=instance_market_options, expected_type=type_hints["instance_market_options"])
                check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
                check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                check_type(argname="argument kernel_id", value=kernel_id, expected_type=type_hints["kernel_id"])
                check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
                check_type(argname="argument license_specifications", value=license_specifications, expected_type=type_hints["license_specifications"])
                check_type(argname="argument maintenance_options", value=maintenance_options, expected_type=type_hints["maintenance_options"])
                check_type(argname="argument metadata_options", value=metadata_options, expected_type=type_hints["metadata_options"])
                check_type(argname="argument monitoring", value=monitoring, expected_type=type_hints["monitoring"])
                check_type(argname="argument network_interfaces", value=network_interfaces, expected_type=type_hints["network_interfaces"])
                check_type(argname="argument placement", value=placement, expected_type=type_hints["placement"])
                check_type(argname="argument private_dns_name_options", value=private_dns_name_options, expected_type=type_hints["private_dns_name_options"])
                check_type(argname="argument ram_disk_id", value=ram_disk_id, expected_type=type_hints["ram_disk_id"])
                check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
                check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
                check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
                check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if block_device_mappings is not None:
                self._values["block_device_mappings"] = block_device_mappings
            if capacity_reservation_specification is not None:
                self._values["capacity_reservation_specification"] = capacity_reservation_specification
            if cpu_options is not None:
                self._values["cpu_options"] = cpu_options
            if credit_specification is not None:
                self._values["credit_specification"] = credit_specification
            if disable_api_stop is not None:
                self._values["disable_api_stop"] = disable_api_stop
            if disable_api_termination is not None:
                self._values["disable_api_termination"] = disable_api_termination
            if ebs_optimized is not None:
                self._values["ebs_optimized"] = ebs_optimized
            if elastic_gpu_specifications is not None:
                self._values["elastic_gpu_specifications"] = elastic_gpu_specifications
            if elastic_inference_accelerators is not None:
                self._values["elastic_inference_accelerators"] = elastic_inference_accelerators
            if enclave_options is not None:
                self._values["enclave_options"] = enclave_options
            if hibernation_options is not None:
                self._values["hibernation_options"] = hibernation_options
            if iam_instance_profile is not None:
                self._values["iam_instance_profile"] = iam_instance_profile
            if image_id is not None:
                self._values["image_id"] = image_id
            if instance_initiated_shutdown_behavior is not None:
                self._values["instance_initiated_shutdown_behavior"] = instance_initiated_shutdown_behavior
            if instance_market_options is not None:
                self._values["instance_market_options"] = instance_market_options
            if instance_requirements is not None:
                self._values["instance_requirements"] = instance_requirements
            if instance_type is not None:
                self._values["instance_type"] = instance_type
            if kernel_id is not None:
                self._values["kernel_id"] = kernel_id
            if key_name is not None:
                self._values["key_name"] = key_name
            if license_specifications is not None:
                self._values["license_specifications"] = license_specifications
            if maintenance_options is not None:
                self._values["maintenance_options"] = maintenance_options
            if metadata_options is not None:
                self._values["metadata_options"] = metadata_options
            if monitoring is not None:
                self._values["monitoring"] = monitoring
            if network_interfaces is not None:
                self._values["network_interfaces"] = network_interfaces
            if placement is not None:
                self._values["placement"] = placement
            if private_dns_name_options is not None:
                self._values["private_dns_name_options"] = private_dns_name_options
            if ram_disk_id is not None:
                self._values["ram_disk_id"] = ram_disk_id
            if security_group_ids is not None:
                self._values["security_group_ids"] = security_group_ids
            if security_groups is not None:
                self._values["security_groups"] = security_groups
            if tag_specifications is not None:
                self._values["tag_specifications"] = tag_specifications
            if user_data is not None:
                self._values["user_data"] = user_data

        @builtins.property
        def block_device_mappings(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.BlockDeviceMappingProperty"]]]]:
            '''The block device mapping.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-blockdevicemappings
            '''
            result = self._values.get("block_device_mappings")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.BlockDeviceMappingProperty"]]]], result)

        @builtins.property
        def capacity_reservation_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CapacityReservationSpecificationProperty"]]:
            '''The Capacity Reservation targeting option.

            If you do not specify this parameter, the instance's Capacity Reservation preference defaults to ``open`` , which enables it to run in any open Capacity Reservation that has matching attributes (instance type, platform, Availability Zone).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-capacityreservationspecification
            '''
            result = self._values.get("capacity_reservation_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CapacityReservationSpecificationProperty"]], result)

        @builtins.property
        def cpu_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CpuOptionsProperty"]]:
            '''The CPU options for the instance.

            For more information, see `Optimizing CPU Options <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-optimize-cpu.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-cpuoptions
            '''
            result = self._values.get("cpu_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CpuOptionsProperty"]], result)

        @builtins.property
        def credit_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CreditSpecificationProperty"]]:
            '''The credit option for CPU usage of the instance.

            Valid only for T instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-creditspecification
            '''
            result = self._values.get("credit_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.CreditSpecificationProperty"]], result)

        @builtins.property
        def disable_api_stop(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to enable the instance for stop protection.

            For more information, see `Stop protection <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html#Using_StopProtection>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-disableapistop
            '''
            result = self._values.get("disable_api_stop")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def disable_api_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''If you set this parameter to ``true`` , you can't terminate the instance using the Amazon EC2 console, CLI, or API;

            otherwise, you can. To change this attribute after launch, use `ModifyInstanceAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html>`_ . Alternatively, if you set ``InstanceInitiatedShutdownBehavior`` to ``terminate`` , you can terminate the instance by running the shutdown command from the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-disableapitermination
            '''
            result = self._values.get("disable_api_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def ebs_optimized(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the instance is optimized for Amazon EBS I/O.

            This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-ebsoptimized
            '''
            result = self._values.get("ebs_optimized")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def elastic_gpu_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.ElasticGpuSpecificationProperty"]]]]:
            '''Deprecated.

            .. epigraph::

               Amazon Elastic Graphics reached end of life on January 8, 2024. For workloads that require graphics acceleration, we recommend that you use Amazon EC2 G4ad, G4dn, or G5 instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-elasticgpuspecifications
            '''
            result = self._values.get("elastic_gpu_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.ElasticGpuSpecificationProperty"]]]], result)

        @builtins.property
        def elastic_inference_accelerators(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty"]]]]:
            '''An elastic inference accelerator to associate with the instance.

            Elastic inference accelerators are a resource you can attach to your Amazon EC2 instances to accelerate your Deep Learning (DL) inference workloads.

            You cannot specify accelerators from different generations in the same request.
            .. epigraph::

               Starting April 15, 2023, AWS will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, Amazon ECS, or Amazon EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-elasticinferenceaccelerators
            '''
            result = self._values.get("elastic_inference_accelerators")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty"]]]], result)

        @builtins.property
        def enclave_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnclaveOptionsProperty"]]:
            '''Indicates whether the instance is enabled for AWS Nitro Enclaves.

            For more information, see `What is AWS Nitro Enclaves? <https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave.html>`_ in the *AWS Nitro Enclaves User Guide* .

            You can't enable AWS Nitro Enclaves and hibernation on the same instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-enclaveoptions
            '''
            result = self._values.get("enclave_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnclaveOptionsProperty"]], result)

        @builtins.property
        def hibernation_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.HibernationOptionsProperty"]]:
            '''Indicates whether an instance is enabled for hibernation.

            This parameter is valid only if the instance meets the `hibernation prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html>`_ . For more information, see `Hibernate your instance <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-hibernationoptions
            '''
            result = self._values.get("hibernation_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.HibernationOptionsProperty"]], result)

        @builtins.property
        def iam_instance_profile(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.IamInstanceProfileProperty"]]:
            '''The name or Amazon Resource Name (ARN) of an IAM instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-iaminstanceprofile
            '''
            result = self._values.get("iam_instance_profile")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.IamInstanceProfileProperty"]], result)

        @builtins.property
        def image_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the AMI.

            Alternatively, you can specify a Systems Manager parameter, which will resolve to an AMI ID on launch.

            Valid formats:

            - ``ami-17characters00000``
            - ``resolve:ssm:parameter-name``
            - ``resolve:ssm:parameter-name:version-number``
            - ``resolve:ssm:parameter-name:label``

            For more information, see `Use a Systems Manager parameter to find an AMI <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html#using-systems-manager-parameter-to-find-AMI>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-imageid
            '''
            result = self._values.get("image_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_initiated_shutdown_behavior(self) -> typing.Optional[builtins.str]:
            '''Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown).

            Default: ``stop``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-instanceinitiatedshutdownbehavior
            '''
            result = self._values.get("instance_initiated_shutdown_behavior")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_market_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.InstanceMarketOptionsProperty"]]:
            '''The market (purchasing) option for the instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-instancemarketoptions
            '''
            result = self._values.get("instance_market_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.InstanceMarketOptionsProperty"]], result)

        @builtins.property
        def instance_requirements(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.InstanceRequirementsProperty"]]:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with these attributes.

            You must specify ``VCpuCount`` and ``MemoryMiB`` . All other attributes are optional. Any unspecified optional attribute is set to its default.

            When you specify multiple attributes, you get instance types that satisfy all of the specified attributes. If you specify multiple values for an attribute, you get instance types that satisfy any of the specified values.

            To limit the list of instance types from which Amazon EC2 can identify matching instance types, you can use one of the following parameters, but not both in the same request:

            - ``AllowedInstanceTypes`` - The instance types to include in the list. All other instance types are ignored, even if they match your specified attributes.
            - ``ExcludedInstanceTypes`` - The instance types to exclude from the list, even if they match your specified attributes.

            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

               Attribute-based instance type selection is only supported when using Auto Scaling groups, EC2 Fleet, and Spot Fleet to launch instances. If you plan to use the launch template in the `launch instance wizard <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html>`_ , or with the `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ API or `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ AWS CloudFormation resource, you can't specify ``InstanceRequirements`` .

            For more information, see `Attribute-based instance type selection for EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html>`_ , `Attribute-based instance type selection for Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html>`_ , and `Spot placement score <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-instancerequirements
            '''
            result = self._values.get("instance_requirements")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.InstanceRequirementsProperty"]], result)

        @builtins.property
        def instance_type(self) -> typing.Optional[builtins.str]:
            '''The instance type. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            If you specify ``InstanceType`` , you can't specify ``InstanceRequirements`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-instancetype
            '''
            result = self._values.get("instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def kernel_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the kernel.

            We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `User Provided Kernels <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-kernelid
            '''
            result = self._values.get("kernel_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def key_name(self) -> typing.Optional[builtins.str]:
            '''The name of the key pair. You can create a key pair using `CreateKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateKeyPair.html>`_ or `ImportKeyPair <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportKeyPair.html>`_ .

            .. epigraph::

               If you do not specify a key pair, you can't connect to the instance unless you choose an AMI that is configured to allow users another way to log in.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-keyname
            '''
            result = self._values.get("key_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def license_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LicenseSpecificationProperty"]]]]:
            '''The license configurations.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-licensespecifications
            '''
            result = self._values.get("license_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.LicenseSpecificationProperty"]]]], result)

        @builtins.property
        def maintenance_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MaintenanceOptionsProperty"]]:
            '''The maintenance options of your instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-maintenanceoptions
            '''
            result = self._values.get("maintenance_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MaintenanceOptionsProperty"]], result)

        @builtins.property
        def metadata_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MetadataOptionsProperty"]]:
            '''The metadata options for the instance.

            For more information, see `Instance metadata and user data <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions
            '''
            result = self._values.get("metadata_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MetadataOptionsProperty"]], result)

        @builtins.property
        def monitoring(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MonitoringProperty"]]:
            '''The monitoring for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-monitoring
            '''
            result = self._values.get("monitoring")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.MonitoringProperty"]], result)

        @builtins.property
        def network_interfaces(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkInterfaceProperty"]]]]:
            '''One or more network interfaces.

            If you specify a network interface, you must specify any security groups and subnets as part of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-networkinterfaces
            '''
            result = self._values.get("network_interfaces")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.NetworkInterfaceProperty"]]]], result)

        @builtins.property
        def placement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PlacementProperty"]]:
            '''The placement for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-placement
            '''
            result = self._values.get("placement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PlacementProperty"]], result)

        @builtins.property
        def private_dns_name_options(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PrivateDnsNameOptionsProperty"]]:
            '''The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries should be handled.

            For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-privatednsnameoptions
            '''
            result = self._values.get("private_dns_name_options")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PrivateDnsNameOptionsProperty"]], result)

        @builtins.property
        def ram_disk_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the RAM disk.

            .. epigraph::

               We recommend that you use PV-GRUB instead of kernels and RAM disks. For more information, see `User provided kernels <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UserProvidedkernels.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-ramdiskid
            '''
            result = self._values.get("ram_disk_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IDs of the security groups.

            You can specify the IDs of existing security groups and references to resources created by the stack template.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-securitygroupids
            '''
            result = self._values.get("security_group_ids")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def security_groups(self) -> typing.Optional[typing.List[builtins.str]]:
            '''One or more security group names.

            For a nondefault VPC, you must use security group IDs instead.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-securitygroups
            '''
            result = self._values.get("security_groups")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def tag_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.TagSpecificationProperty"]]]]:
            '''The tags to apply to the resources that are created during instance launch.

            To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ .

            To tag the launch template itself, use `TagSpecifications <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-tagspecifications
            '''
            result = self._values.get("tag_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.TagSpecificationProperty"]]]], result)

        @builtins.property
        def user_data(self) -> typing.Optional[builtins.str]:
            '''The user data to make available to the instance.

            You must provide base64-encoded text. User data is limited to 16 KB. For more information, see `Run commands on your Linux instance at launch <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html>`_ (Linux) or `Work with instance user data <https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/instancedata-add-user-data.html>`_ (Windows) in the *Amazon Elastic Compute Cloud User Guide* .

            If you are creating the launch template for use with AWS Batch , the user data must be provided in the `MIME multi-part archive format <https://docs.aws.amazon.com/https://cloudinit.readthedocs.io/en/latest/topics/format.html#mime-multi-part-archive>`_ . For more information, see `Amazon EC2 user data in launch templates <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html>`_ in the *AWS Batch User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-userdata
            '''
            result = self._values.get("user_data")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateDataProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty",
        jsii_struct_bases=[],
        name_mapping={"count": "count", "type": "type"},
    )
    class LaunchTemplateElasticInferenceAcceleratorProperty:
        def __init__(
            self,
            *,
            count: typing.Optional[jsii.Number] = None,
            type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies an elastic inference accelerator.

            ``LaunchTemplateElasticInferenceAccelerator`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param count: The number of elastic inference accelerators to attach to the instance. Default: 1
            :param type: The type of elastic inference accelerator. The possible values are eia1.medium, eia1.large, and eia1.xlarge.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplateelasticinferenceaccelerator.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_elastic_inference_accelerator_property = ec2.CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty(
                    count=123,
                    type="type"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__335c8358d83d825d536f0cf63b36a23109d7286d681edac96c843bd6d30e6485)
                check_type(argname="argument count", value=count, expected_type=type_hints["count"])
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if count is not None:
                self._values["count"] = count
            if type is not None:
                self._values["type"] = type

        @builtins.property
        def count(self) -> typing.Optional[jsii.Number]:
            '''The number of elastic inference accelerators to attach to the instance.

            Default: 1

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplateelasticinferenceaccelerator.html#cfn-ec2-launchtemplate-launchtemplateelasticinferenceaccelerator-count
            '''
            result = self._values.get("count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def type(self) -> typing.Optional[builtins.str]:
            '''The type of elastic inference accelerator.

            The possible values are eia1.medium, eia1.large, and eia1.xlarge.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplateelasticinferenceaccelerator.html#cfn-ec2-launchtemplate-launchtemplateelasticinferenceaccelerator-type
            '''
            result = self._values.get("type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateElasticInferenceAcceleratorProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class LaunchTemplateTagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies the tags to apply to the launch template during creation.

            ``LaunchTemplateTagSpecification`` is a property of `AWS::EC2::LaunchTemplate <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html>`_ .

            :param resource_type: The type of resource. To tag the launch template, ``ResourceType`` must be ``launch-template`` .
            :param tags: The tags for the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatetagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_tag_specification_property = ec2.CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ea8bb22edecf7fdaa9bcd65bdd6872e8d86dce7ec73542de8ada65dfd42f6a16)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource.

            To tag the launch template, ``ResourceType`` must be ``launch-template`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatetagspecification.html#cfn-ec2-launchtemplate-launchtemplatetagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags for the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatetagspecification.html#cfn-ec2-launchtemplate-launchtemplatetagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateTagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.LicenseSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"license_configuration_arn": "licenseConfigurationArn"},
    )
    class LicenseSpecificationProperty:
        def __init__(
            self,
            *,
            license_configuration_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a license configuration for an instance.

            ``LicenseSpecification`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param license_configuration_arn: The Amazon Resource Name (ARN) of the license configuration.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-licensespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                license_specification_property = ec2.CfnLaunchTemplate.LicenseSpecificationProperty(
                    license_configuration_arn="licenseConfigurationArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__da6f057643821e4198778db605300559763cd1d337144d841e7dd3934ae323b5)
                check_type(argname="argument license_configuration_arn", value=license_configuration_arn, expected_type=type_hints["license_configuration_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if license_configuration_arn is not None:
                self._values["license_configuration_arn"] = license_configuration_arn

        @builtins.property
        def license_configuration_arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the license configuration.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-licensespecification.html#cfn-ec2-launchtemplate-licensespecification-licenseconfigurationarn
            '''
            result = self._values.get("license_configuration_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LicenseSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.MaintenanceOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "auto_recovery": "autoRecovery",
            "reboot_migration": "rebootMigration",
        },
    )
    class MaintenanceOptionsProperty:
        def __init__(
            self,
            *,
            auto_recovery: typing.Optional[builtins.str] = None,
            reboot_migration: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The maintenance options of your instance.

            :param auto_recovery: Disables the automatic recovery behavior of your instance or sets it to default.
            :param reboot_migration: Disables the automatic reboot-migration behavior of your instance or sets it to default.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-maintenanceoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                maintenance_options_property = ec2.CfnLaunchTemplate.MaintenanceOptionsProperty(
                    auto_recovery="autoRecovery",
                    reboot_migration="rebootMigration"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__62e0d77a7fa9500aab5a08e932dc82213f11e05b31cf56f4654431c48342979e)
                check_type(argname="argument auto_recovery", value=auto_recovery, expected_type=type_hints["auto_recovery"])
                check_type(argname="argument reboot_migration", value=reboot_migration, expected_type=type_hints["reboot_migration"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if auto_recovery is not None:
                self._values["auto_recovery"] = auto_recovery
            if reboot_migration is not None:
                self._values["reboot_migration"] = reboot_migration

        @builtins.property
        def auto_recovery(self) -> typing.Optional[builtins.str]:
            '''Disables the automatic recovery behavior of your instance or sets it to default.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-maintenanceoptions.html#cfn-ec2-launchtemplate-maintenanceoptions-autorecovery
            '''
            result = self._values.get("auto_recovery")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def reboot_migration(self) -> typing.Optional[builtins.str]:
            '''Disables the automatic reboot-migration behavior of your instance or sets it to default.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-maintenanceoptions.html#cfn-ec2-launchtemplate-maintenanceoptions-rebootmigration
            '''
            result = self._values.get("reboot_migration")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MaintenanceOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.MemoryGiBPerVCpuProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryGiBPerVCpuProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            :param max: The maximum amount of memory per vCPU, in GiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory per vCPU, in GiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorygibpervcpu.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_gi_bPer_vCpu_property = ec2.CfnLaunchTemplate.MemoryGiBPerVCpuProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__2a61d16c29143184627c19c38cbfe78c2ad238ed306df35964b3c1b3daa551f0)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory per vCPU, in GiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorygibpervcpu.html#cfn-ec2-launchtemplate-memorygibpervcpu-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory per vCPU, in GiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorygibpervcpu.html#cfn-ec2-launchtemplate-memorygibpervcpu-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryGiBPerVCpuProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.MemoryMiBProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryMiBProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory, in MiB.

            :param max: The maximum amount of memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory, in MiB. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorymib.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_mi_bProperty = ec2.CfnLaunchTemplate.MemoryMiBProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__5a944decb01c5cdfad894fed636b8467086175402c62f51700738f964ec9fee8)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorymib.html#cfn-ec2-launchtemplate-memorymib-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory, in MiB.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-memorymib.html#cfn-ec2-launchtemplate-memorymib-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryMiBProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.MetadataOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "http_endpoint": "httpEndpoint",
            "http_protocol_ipv6": "httpProtocolIpv6",
            "http_put_response_hop_limit": "httpPutResponseHopLimit",
            "http_tokens": "httpTokens",
            "instance_metadata_tags": "instanceMetadataTags",
        },
    )
    class MetadataOptionsProperty:
        def __init__(
            self,
            *,
            http_endpoint: typing.Optional[builtins.str] = None,
            http_protocol_ipv6: typing.Optional[builtins.str] = None,
            http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
            http_tokens: typing.Optional[builtins.str] = None,
            instance_metadata_tags: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The metadata options for the instance.

            For more information, see `Instance metadata and user data <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html>`_ in the *Amazon EC2 User Guide* .

            ``MetadataOptions`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param http_endpoint: Enables or disables the HTTP metadata endpoint on your instances. If the parameter is not specified, the default state is ``enabled`` . .. epigraph:: If you specify a value of ``disabled`` , you will not be able to access your instance metadata.
            :param http_protocol_ipv6: Enables or disables the IPv6 endpoint for the instance metadata service. Default: ``disabled``
            :param http_put_response_hop_limit: The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel. Default: ``1`` Possible values: Integers from 1 to 64
            :param http_tokens: Indicates whether IMDSv2 is required. - ``optional`` - IMDSv2 is optional. You can choose whether to send a session token in your instance metadata retrieval requests. If you retrieve IAM role credentials without a session token, you receive the IMDSv1 role credentials. If you retrieve IAM role credentials using a valid session token, you receive the IMDSv2 role credentials. - ``required`` - IMDSv2 is required. You must send a session token in your instance metadata retrieval requests. With this option, retrieving the IAM role credentials always returns IMDSv2 credentials; IMDSv1 credentials are not available. Default: If the value of ``ImdsSupport`` for the Amazon Machine Image (AMI) for your instance is ``v2.0`` , the default is ``required`` .
            :param instance_metadata_tags: Set to ``enabled`` to allow access to instance tags from the instance metadata. Set to ``disabled`` to turn off access to instance tags from the instance metadata. For more information, see `Work with instance tags using the instance metadata <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS>`_ . Default: ``disabled``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                metadata_options_property = ec2.CfnLaunchTemplate.MetadataOptionsProperty(
                    http_endpoint="httpEndpoint",
                    http_protocol_ipv6="httpProtocolIpv6",
                    http_put_response_hop_limit=123,
                    http_tokens="httpTokens",
                    instance_metadata_tags="instanceMetadataTags"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__53424c8c7e838584b59a51030b569a856ede8442605f1c59d4e589aa9b5a55aa)
                check_type(argname="argument http_endpoint", value=http_endpoint, expected_type=type_hints["http_endpoint"])
                check_type(argname="argument http_protocol_ipv6", value=http_protocol_ipv6, expected_type=type_hints["http_protocol_ipv6"])
                check_type(argname="argument http_put_response_hop_limit", value=http_put_response_hop_limit, expected_type=type_hints["http_put_response_hop_limit"])
                check_type(argname="argument http_tokens", value=http_tokens, expected_type=type_hints["http_tokens"])
                check_type(argname="argument instance_metadata_tags", value=instance_metadata_tags, expected_type=type_hints["instance_metadata_tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if http_endpoint is not None:
                self._values["http_endpoint"] = http_endpoint
            if http_protocol_ipv6 is not None:
                self._values["http_protocol_ipv6"] = http_protocol_ipv6
            if http_put_response_hop_limit is not None:
                self._values["http_put_response_hop_limit"] = http_put_response_hop_limit
            if http_tokens is not None:
                self._values["http_tokens"] = http_tokens
            if instance_metadata_tags is not None:
                self._values["instance_metadata_tags"] = instance_metadata_tags

        @builtins.property
        def http_endpoint(self) -> typing.Optional[builtins.str]:
            '''Enables or disables the HTTP metadata endpoint on your instances.

            If the parameter is not specified, the default state is ``enabled`` .
            .. epigraph::

               If you specify a value of ``disabled`` , you will not be able to access your instance metadata.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html#cfn-ec2-launchtemplate-metadataoptions-httpendpoint
            '''
            result = self._values.get("http_endpoint")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def http_protocol_ipv6(self) -> typing.Optional[builtins.str]:
            '''Enables or disables the IPv6 endpoint for the instance metadata service.

            Default: ``disabled``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html#cfn-ec2-launchtemplate-metadataoptions-httpprotocolipv6
            '''
            result = self._values.get("http_protocol_ipv6")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def http_put_response_hop_limit(self) -> typing.Optional[jsii.Number]:
            '''The desired HTTP PUT response hop limit for instance metadata requests.

            The larger the number, the further instance metadata requests can travel.

            Default: ``1``

            Possible values: Integers from 1 to 64

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html#cfn-ec2-launchtemplate-metadataoptions-httpputresponsehoplimit
            '''
            result = self._values.get("http_put_response_hop_limit")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def http_tokens(self) -> typing.Optional[builtins.str]:
            '''Indicates whether IMDSv2 is required.

            - ``optional`` - IMDSv2 is optional. You can choose whether to send a session token in your instance metadata retrieval requests. If you retrieve IAM role credentials without a session token, you receive the IMDSv1 role credentials. If you retrieve IAM role credentials using a valid session token, you receive the IMDSv2 role credentials.
            - ``required`` - IMDSv2 is required. You must send a session token in your instance metadata retrieval requests. With this option, retrieving the IAM role credentials always returns IMDSv2 credentials; IMDSv1 credentials are not available.

            Default: If the value of ``ImdsSupport`` for the Amazon Machine Image (AMI) for your instance is ``v2.0`` , the default is ``required`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html#cfn-ec2-launchtemplate-metadataoptions-httptokens
            '''
            result = self._values.get("http_tokens")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_metadata_tags(self) -> typing.Optional[builtins.str]:
            '''Set to ``enabled`` to allow access to instance tags from the instance metadata.

            Set to ``disabled`` to turn off access to instance tags from the instance metadata. For more information, see `Work with instance tags using the instance metadata <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#work-with-tags-in-IMDS>`_ .

            Default: ``disabled``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-metadataoptions.html#cfn-ec2-launchtemplate-metadataoptions-instancemetadatatags
            '''
            result = self._values.get("instance_metadata_tags")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MetadataOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.MonitoringProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled"},
    )
    class MonitoringProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Specifies whether detailed monitoring is enabled for an instance.

            For more information about detailed monitoring, see `Enable or turn off detailed monitoring for your instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html>`_ in the *Amazon EC2 User Guide* .

            ``Monitoring`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param enabled: Specify ``true`` to enable detailed monitoring. Otherwise, basic monitoring is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-monitoring.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                monitoring_property = ec2.CfnLaunchTemplate.MonitoringProperty(
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__18aa644a0bded5ce11cab52fe105e536d6c67cdb32ec43c901bef4004e8f0d1f)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Specify ``true`` to enable detailed monitoring.

            Otherwise, basic monitoring is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-monitoring.html#cfn-ec2-launchtemplate-monitoring-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MonitoringProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.NetworkBandwidthGbpsProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkBandwidthGbpsProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of network bandwidth, in gigabits per second (Gbps).

            .. epigraph::

               Setting the minimum bandwidth does not guarantee that your instance will achieve the minimum bandwidth. Amazon EC2 will identify instance types that support the specified minimum bandwidth, but the actual bandwidth of your instance might go below the specified minimum at times. For more information, see `Available instance bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html#available-instance-bandwidth>`_ in the *Amazon EC2 User Guide* .

            :param max: The maximum amount of network bandwidth, in Gbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of network bandwidth, in Gbps. If this parameter is not specified, there is no minimum limit.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkbandwidthgbps.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_bandwidth_gbps_property = ec2.CfnLaunchTemplate.NetworkBandwidthGbpsProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9fedac138bd208bcab5a0d4ff7efbf5e7060acf961679f611e096cb15a8613f6)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of network bandwidth, in Gbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkbandwidthgbps.html#cfn-ec2-launchtemplate-networkbandwidthgbps-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of network bandwidth, in Gbps.

            If this parameter is not specified, there is no minimum limit.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkbandwidthgbps.html#cfn-ec2-launchtemplate-networkbandwidthgbps-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkBandwidthGbpsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.NetworkInterfaceCountProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkInterfaceCountProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of network interfaces.

            :param max: The maximum number of network interfaces. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of network interfaces. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterfacecount.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_count_property = ec2.CfnLaunchTemplate.NetworkInterfaceCountProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__66fb50fedba927998c968d23061fff00f81c8ed406ead86c6cfb8a3628696169)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of network interfaces.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterfacecount.html#cfn-ec2-launchtemplate-networkinterfacecount-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of network interfaces.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterfacecount.html#cfn-ec2-launchtemplate-networkinterfacecount-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceCountProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.NetworkInterfaceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "associate_carrier_ip_address": "associateCarrierIpAddress",
            "associate_public_ip_address": "associatePublicIpAddress",
            "connection_tracking_specification": "connectionTrackingSpecification",
            "delete_on_termination": "deleteOnTermination",
            "description": "description",
            "device_index": "deviceIndex",
            "ena_srd_specification": "enaSrdSpecification",
            "groups": "groups",
            "interface_type": "interfaceType",
            "ipv4_prefix_count": "ipv4PrefixCount",
            "ipv4_prefixes": "ipv4Prefixes",
            "ipv6_address_count": "ipv6AddressCount",
            "ipv6_addresses": "ipv6Addresses",
            "ipv6_prefix_count": "ipv6PrefixCount",
            "ipv6_prefixes": "ipv6Prefixes",
            "network_card_index": "networkCardIndex",
            "network_interface_id": "networkInterfaceId",
            "primary_ipv6": "primaryIpv6",
            "private_ip_address": "privateIpAddress",
            "private_ip_addresses": "privateIpAddresses",
            "secondary_private_ip_address_count": "secondaryPrivateIpAddressCount",
            "subnet_id": "subnetId",
        },
    )
    class NetworkInterfaceProperty:
        def __init__(
            self,
            *,
            associate_carrier_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.ConnectionTrackingSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            description: typing.Optional[builtins.str] = None,
            device_index: typing.Optional[jsii.Number] = None,
            ena_srd_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.EnaSrdSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            groups: typing.Optional[typing.Sequence[builtins.str]] = None,
            interface_type: typing.Optional[builtins.str] = None,
            ipv4_prefix_count: typing.Optional[jsii.Number] = None,
            ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.Ipv4PrefixSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            ipv6_address_count: typing.Optional[jsii.Number] = None,
            ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.Ipv6AddProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            ipv6_prefix_count: typing.Optional[jsii.Number] = None,
            ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.Ipv6PrefixSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            network_card_index: typing.Optional[jsii.Number] = None,
            network_interface_id: typing.Optional[builtins.str] = None,
            primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            private_ip_address: typing.Optional[builtins.str] = None,
            private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLaunchTemplate.PrivateIpAddProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
            subnet_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the parameters for a network interface.

            ``NetworkInterface`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param associate_carrier_ip_address: Associates a Carrier IP address with eth0 for a new network interface. Use this option when you launch an instance in a Wavelength Zone and want to associate a Carrier IP address with the network interface. For more information about Carrier IP addresses, see `Carrier IP addresses <https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#provider-owned-ip>`_ in the *AWS Wavelength Developer Guide* .
            :param associate_public_ip_address: Associates a public IPv4 address with eth0 for a new network interface. AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `Amazon VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .
            :param connection_tracking_specification: A connection tracking specification for the network interface.
            :param delete_on_termination: Indicates whether the network interface is deleted when the instance is terminated.
            :param description: A description for the network interface.
            :param device_index: The device index for the network interface attachment.
            :param ena_srd_specification: The ENA Express configuration for the network interface.
            :param groups: The IDs of one or more security groups.
            :param interface_type: The type of network interface. To create an Elastic Fabric Adapter (EFA), specify ``efa`` . For more information, see `Elastic Fabric Adapter <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . If you are not creating an EFA, specify ``interface`` or omit this parameter. Valid values: ``interface`` | ``efa``
            :param ipv4_prefix_count: The number of IPv4 prefixes to be automatically assigned to the network interface. You cannot use this option if you use the ``Ipv4Prefix`` option.
            :param ipv4_prefixes: One or more IPv4 prefixes to be assigned to the network interface. You cannot use this option if you use the ``Ipv4PrefixCount`` option.
            :param ipv6_address_count: The number of IPv6 addresses to assign to a network interface. Amazon EC2 automatically selects the IPv6 addresses from the subnet range. You can't use this option if specifying specific IPv6 addresses.
            :param ipv6_addresses: One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet. You can't use this option if you're specifying a number of IPv6 addresses.
            :param ipv6_prefix_count: The number of IPv6 prefixes to be automatically assigned to the network interface. You cannot use this option if you use the ``Ipv6Prefix`` option.
            :param ipv6_prefixes: One or more IPv6 prefixes to be assigned to the network interface. You cannot use this option if you use the ``Ipv6PrefixCount`` option.
            :param network_card_index: The index of the network card. Some instance types support multiple network cards. The primary network interface must be assigned to network card index 0. The default is network card index 0.
            :param network_interface_id: The ID of the network interface.
            :param primary_ipv6: The primary IPv6 address of the network interface. 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. For more information about primary IPv6 addresses, see `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ .
            :param private_ip_address: The primary private IPv4 address of the network interface.
            :param private_ip_addresses: One or more private IPv4 addresses.
            :param secondary_private_ip_address_count: The number of secondary private IPv4 addresses to assign to a network interface.
            :param subnet_id: The ID of the subnet for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_property = ec2.CfnLaunchTemplate.NetworkInterfaceProperty(
                    associate_carrier_ip_address=False,
                    associate_public_ip_address=False,
                    connection_tracking_specification=ec2.CfnLaunchTemplate.ConnectionTrackingSpecificationProperty(
                        tcp_established_timeout=123,
                        udp_stream_timeout=123,
                        udp_timeout=123
                    ),
                    delete_on_termination=False,
                    description="description",
                    device_index=123,
                    ena_srd_specification=ec2.CfnLaunchTemplate.EnaSrdSpecificationProperty(
                        ena_srd_enabled=False,
                        ena_srd_udp_specification=ec2.CfnLaunchTemplate.EnaSrdUdpSpecificationProperty(
                            ena_srd_udp_enabled=False
                        )
                    ),
                    groups=["groups"],
                    interface_type="interfaceType",
                    ipv4_prefix_count=123,
                    ipv4_prefixes=[ec2.CfnLaunchTemplate.Ipv4PrefixSpecificationProperty(
                        ipv4_prefix="ipv4Prefix"
                    )],
                    ipv6_address_count=123,
                    ipv6_addresses=[ec2.CfnLaunchTemplate.Ipv6AddProperty(
                        ipv6_address="ipv6Address"
                    )],
                    ipv6_prefix_count=123,
                    ipv6_prefixes=[ec2.CfnLaunchTemplate.Ipv6PrefixSpecificationProperty(
                        ipv6_prefix="ipv6Prefix"
                    )],
                    network_card_index=123,
                    network_interface_id="networkInterfaceId",
                    primary_ipv6=False,
                    private_ip_address="privateIpAddress",
                    private_ip_addresses=[ec2.CfnLaunchTemplate.PrivateIpAddProperty(
                        primary=False,
                        private_ip_address="privateIpAddress"
                    )],
                    secondary_private_ip_address_count=123,
                    subnet_id="subnetId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c599e12c3de63926f26bb5da3afad64e8c60b24c3b563faa2986e88c15da4421)
                check_type(argname="argument associate_carrier_ip_address", value=associate_carrier_ip_address, expected_type=type_hints["associate_carrier_ip_address"])
                check_type(argname="argument associate_public_ip_address", value=associate_public_ip_address, expected_type=type_hints["associate_public_ip_address"])
                check_type(argname="argument connection_tracking_specification", value=connection_tracking_specification, expected_type=type_hints["connection_tracking_specification"])
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument device_index", value=device_index, expected_type=type_hints["device_index"])
                check_type(argname="argument ena_srd_specification", value=ena_srd_specification, expected_type=type_hints["ena_srd_specification"])
                check_type(argname="argument groups", value=groups, expected_type=type_hints["groups"])
                check_type(argname="argument interface_type", value=interface_type, expected_type=type_hints["interface_type"])
                check_type(argname="argument ipv4_prefix_count", value=ipv4_prefix_count, expected_type=type_hints["ipv4_prefix_count"])
                check_type(argname="argument ipv4_prefixes", value=ipv4_prefixes, expected_type=type_hints["ipv4_prefixes"])
                check_type(argname="argument ipv6_address_count", value=ipv6_address_count, expected_type=type_hints["ipv6_address_count"])
                check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
                check_type(argname="argument ipv6_prefix_count", value=ipv6_prefix_count, expected_type=type_hints["ipv6_prefix_count"])
                check_type(argname="argument ipv6_prefixes", value=ipv6_prefixes, expected_type=type_hints["ipv6_prefixes"])
                check_type(argname="argument network_card_index", value=network_card_index, expected_type=type_hints["network_card_index"])
                check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
                check_type(argname="argument primary_ipv6", value=primary_ipv6, expected_type=type_hints["primary_ipv6"])
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
                check_type(argname="argument private_ip_addresses", value=private_ip_addresses, expected_type=type_hints["private_ip_addresses"])
                check_type(argname="argument secondary_private_ip_address_count", value=secondary_private_ip_address_count, expected_type=type_hints["secondary_private_ip_address_count"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if associate_carrier_ip_address is not None:
                self._values["associate_carrier_ip_address"] = associate_carrier_ip_address
            if associate_public_ip_address is not None:
                self._values["associate_public_ip_address"] = associate_public_ip_address
            if connection_tracking_specification is not None:
                self._values["connection_tracking_specification"] = connection_tracking_specification
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if description is not None:
                self._values["description"] = description
            if device_index is not None:
                self._values["device_index"] = device_index
            if ena_srd_specification is not None:
                self._values["ena_srd_specification"] = ena_srd_specification
            if groups is not None:
                self._values["groups"] = groups
            if interface_type is not None:
                self._values["interface_type"] = interface_type
            if ipv4_prefix_count is not None:
                self._values["ipv4_prefix_count"] = ipv4_prefix_count
            if ipv4_prefixes is not None:
                self._values["ipv4_prefixes"] = ipv4_prefixes
            if ipv6_address_count is not None:
                self._values["ipv6_address_count"] = ipv6_address_count
            if ipv6_addresses is not None:
                self._values["ipv6_addresses"] = ipv6_addresses
            if ipv6_prefix_count is not None:
                self._values["ipv6_prefix_count"] = ipv6_prefix_count
            if ipv6_prefixes is not None:
                self._values["ipv6_prefixes"] = ipv6_prefixes
            if network_card_index is not None:
                self._values["network_card_index"] = network_card_index
            if network_interface_id is not None:
                self._values["network_interface_id"] = network_interface_id
            if primary_ipv6 is not None:
                self._values["primary_ipv6"] = primary_ipv6
            if private_ip_address is not None:
                self._values["private_ip_address"] = private_ip_address
            if private_ip_addresses is not None:
                self._values["private_ip_addresses"] = private_ip_addresses
            if secondary_private_ip_address_count is not None:
                self._values["secondary_private_ip_address_count"] = secondary_private_ip_address_count
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id

        @builtins.property
        def associate_carrier_ip_address(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Associates a Carrier IP address with eth0 for a new network interface.

            Use this option when you launch an instance in a Wavelength Zone and want to associate a Carrier IP address with the network interface. For more information about Carrier IP addresses, see `Carrier IP addresses <https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#provider-owned-ip>`_ in the *AWS Wavelength Developer Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-associatecarrieripaddress
            '''
            result = self._values.get("associate_carrier_ip_address")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def associate_public_ip_address(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Associates a public IPv4 address with eth0 for a new network interface.

            AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `Amazon VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-associatepublicipaddress
            '''
            result = self._values.get("associate_public_ip_address")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def connection_tracking_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.ConnectionTrackingSpecificationProperty"]]:
            '''A connection tracking specification for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-connectiontrackingspecification
            '''
            result = self._values.get("connection_tracking_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.ConnectionTrackingSpecificationProperty"]], result)

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the network interface is deleted when the instance is terminated.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''A description for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def device_index(self) -> typing.Optional[jsii.Number]:
            '''The device index for the network interface attachment.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-deviceindex
            '''
            result = self._values.get("device_index")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ena_srd_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnaSrdSpecificationProperty"]]:
            '''The ENA Express configuration for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-enasrdspecification
            '''
            result = self._values.get("ena_srd_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.EnaSrdSpecificationProperty"]], result)

        @builtins.property
        def groups(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IDs of one or more security groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-groups
            '''
            result = self._values.get("groups")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def interface_type(self) -> typing.Optional[builtins.str]:
            '''The type of network interface.

            To create an Elastic Fabric Adapter (EFA), specify ``efa`` . For more information, see `Elastic Fabric Adapter <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            If you are not creating an EFA, specify ``interface`` or omit this parameter.

            Valid values: ``interface`` | ``efa``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-interfacetype
            '''
            result = self._values.get("interface_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ipv4_prefix_count(self) -> typing.Optional[jsii.Number]:
            '''The number of IPv4 prefixes to be automatically assigned to the network interface.

            You cannot use this option if you use the ``Ipv4Prefix`` option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv4prefixcount
            '''
            result = self._values.get("ipv4_prefix_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ipv4_prefixes(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv4PrefixSpecificationProperty"]]]]:
            '''One or more IPv4 prefixes to be assigned to the network interface.

            You cannot use this option if you use the ``Ipv4PrefixCount`` option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv4prefixes
            '''
            result = self._values.get("ipv4_prefixes")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv4PrefixSpecificationProperty"]]]], result)

        @builtins.property
        def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
            '''The number of IPv6 addresses to assign to a network interface.

            Amazon EC2 automatically selects the IPv6 addresses from the subnet range. You can't use this option if specifying specific IPv6 addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv6addresscount
            '''
            result = self._values.get("ipv6_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ipv6_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv6AddProperty"]]]]:
            '''One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet.

            You can't use this option if you're specifying a number of IPv6 addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv6addresses
            '''
            result = self._values.get("ipv6_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv6AddProperty"]]]], result)

        @builtins.property
        def ipv6_prefix_count(self) -> typing.Optional[jsii.Number]:
            '''The number of IPv6 prefixes to be automatically assigned to the network interface.

            You cannot use this option if you use the ``Ipv6Prefix`` option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv6prefixcount
            '''
            result = self._values.get("ipv6_prefix_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ipv6_prefixes(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv6PrefixSpecificationProperty"]]]]:
            '''One or more IPv6 prefixes to be assigned to the network interface.

            You cannot use this option if you use the ``Ipv6PrefixCount`` option.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-ipv6prefixes
            '''
            result = self._values.get("ipv6_prefixes")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.Ipv6PrefixSpecificationProperty"]]]], result)

        @builtins.property
        def network_card_index(self) -> typing.Optional[jsii.Number]:
            '''The index of the network card.

            Some instance types support multiple network cards. The primary network interface must be assigned to network card index 0. The default is network card index 0.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-networkcardindex
            '''
            result = self._values.get("network_card_index")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def network_interface_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-networkinterfaceid
            '''
            result = self._values.get("network_interface_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def primary_ipv6(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''The primary IPv6 address of the network interface.

            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. For more information about primary IPv6 addresses, see `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-primaryipv6
            '''
            result = self._values.get("primary_ipv6")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def private_ip_address(self) -> typing.Optional[builtins.str]:
            '''The primary private IPv4 address of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def private_ip_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PrivateIpAddProperty"]]]]:
            '''One or more private IPv4 addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-privateipaddresses
            '''
            result = self._values.get("private_ip_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnLaunchTemplate.PrivateIpAddProperty"]]]], result)

        @builtins.property
        def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
            '''The number of secondary private IPv4 addresses to assign to a network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-secondaryprivateipaddresscount
            '''
            result = self._values.get("secondary_private_ip_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the subnet for the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.PlacementProperty",
        jsii_struct_bases=[],
        name_mapping={
            "affinity": "affinity",
            "availability_zone": "availabilityZone",
            "group_id": "groupId",
            "group_name": "groupName",
            "host_id": "hostId",
            "host_resource_group_arn": "hostResourceGroupArn",
            "partition_number": "partitionNumber",
            "spread_domain": "spreadDomain",
            "tenancy": "tenancy",
        },
    )
    class PlacementProperty:
        def __init__(
            self,
            *,
            affinity: typing.Optional[builtins.str] = None,
            availability_zone: typing.Optional[builtins.str] = None,
            group_id: typing.Optional[builtins.str] = None,
            group_name: typing.Optional[builtins.str] = None,
            host_id: typing.Optional[builtins.str] = None,
            host_resource_group_arn: typing.Optional[builtins.str] = None,
            partition_number: typing.Optional[jsii.Number] = None,
            spread_domain: typing.Optional[builtins.str] = None,
            tenancy: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the placement of an instance.

            ``Placement`` is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param affinity: The affinity setting for an instance on a Dedicated Host.
            :param availability_zone: The Availability Zone for the instance.
            :param group_id: The Group Id of a placement group. You must specify the Placement Group *Group Id* to launch an instance in a shared placement group.
            :param group_name: The name of the placement group for the instance.
            :param host_id: The ID of the Dedicated Host for the instance.
            :param host_resource_group_arn: The ARN of the host resource group in which to launch the instances. If you specify a host resource group ARN, omit the *Tenancy* parameter or set it to ``host`` .
            :param partition_number: The number of the partition the instance should launch in. Valid only if the placement group strategy is set to ``partition`` .
            :param spread_domain: Reserved for future use.
            :param tenancy: The tenancy of the instance. An instance with a tenancy of dedicated runs on single-tenant hardware.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                placement_property = ec2.CfnLaunchTemplate.PlacementProperty(
                    affinity="affinity",
                    availability_zone="availabilityZone",
                    group_id="groupId",
                    group_name="groupName",
                    host_id="hostId",
                    host_resource_group_arn="hostResourceGroupArn",
                    partition_number=123,
                    spread_domain="spreadDomain",
                    tenancy="tenancy"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ab6cfd4307c62f4b0cd9a09bdc9e9e2583df0d1ddc9984a975653e43f89e243e)
                check_type(argname="argument affinity", value=affinity, expected_type=type_hints["affinity"])
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
                check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
                check_type(argname="argument host_id", value=host_id, expected_type=type_hints["host_id"])
                check_type(argname="argument host_resource_group_arn", value=host_resource_group_arn, expected_type=type_hints["host_resource_group_arn"])
                check_type(argname="argument partition_number", value=partition_number, expected_type=type_hints["partition_number"])
                check_type(argname="argument spread_domain", value=spread_domain, expected_type=type_hints["spread_domain"])
                check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if affinity is not None:
                self._values["affinity"] = affinity
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if group_id is not None:
                self._values["group_id"] = group_id
            if group_name is not None:
                self._values["group_name"] = group_name
            if host_id is not None:
                self._values["host_id"] = host_id
            if host_resource_group_arn is not None:
                self._values["host_resource_group_arn"] = host_resource_group_arn
            if partition_number is not None:
                self._values["partition_number"] = partition_number
            if spread_domain is not None:
                self._values["spread_domain"] = spread_domain
            if tenancy is not None:
                self._values["tenancy"] = tenancy

        @builtins.property
        def affinity(self) -> typing.Optional[builtins.str]:
            '''The affinity setting for an instance on a Dedicated Host.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-affinity
            '''
            result = self._values.get("affinity")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def group_id(self) -> typing.Optional[builtins.str]:
            '''The Group Id of a placement group.

            You must specify the Placement Group *Group Id* to launch an instance in a shared placement group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-groupid
            '''
            result = self._values.get("group_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def group_name(self) -> typing.Optional[builtins.str]:
            '''The name of the placement group for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-groupname
            '''
            result = self._values.get("group_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def host_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the Dedicated Host for the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-hostid
            '''
            result = self._values.get("host_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def host_resource_group_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the host resource group in which to launch the instances.

            If you specify a host resource group ARN, omit the *Tenancy* parameter or set it to ``host`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-hostresourcegrouparn
            '''
            result = self._values.get("host_resource_group_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def partition_number(self) -> typing.Optional[jsii.Number]:
            '''The number of the partition the instance should launch in.

            Valid only if the placement group strategy is set to ``partition`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-partitionnumber
            '''
            result = self._values.get("partition_number")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def spread_domain(self) -> typing.Optional[builtins.str]:
            '''Reserved for future use.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-spreaddomain
            '''
            result = self._values.get("spread_domain")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tenancy(self) -> typing.Optional[builtins.str]:
            '''The tenancy of the instance.

            An instance with a tenancy of dedicated runs on single-tenant hardware.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-placement.html#cfn-ec2-launchtemplate-placement-tenancy
            '''
            result = self._values.get("tenancy")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PlacementProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.PrivateDnsNameOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "enable_resource_name_dns_aaaa_record": "enableResourceNameDnsAaaaRecord",
            "enable_resource_name_dns_a_record": "enableResourceNameDnsARecord",
            "hostname_type": "hostnameType",
        },
    )
    class PrivateDnsNameOptionsProperty:
        def __init__(
            self,
            *,
            enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            hostname_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries should be handled.

            For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :param enable_resource_name_dns_aaaa_record: Indicates whether to respond to DNS queries for instance hostnames with DNS AAAA records.
            :param enable_resource_name_dns_a_record: Indicates whether to respond to DNS queries for instance hostnames with DNS A records.
            :param hostname_type: The type of hostname for EC2 instances. For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privatednsnameoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_dns_name_options_property = ec2.CfnLaunchTemplate.PrivateDnsNameOptionsProperty(
                    enable_resource_name_dns_aaaa_record=False,
                    enable_resource_name_dns_aRecord=False,
                    hostname_type="hostnameType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d69546b29bbd1f224f2ab9c89a842fc901bd4c6722d4900298ab916223412e2a)
                check_type(argname="argument enable_resource_name_dns_aaaa_record", value=enable_resource_name_dns_aaaa_record, expected_type=type_hints["enable_resource_name_dns_aaaa_record"])
                check_type(argname="argument enable_resource_name_dns_a_record", value=enable_resource_name_dns_a_record, expected_type=type_hints["enable_resource_name_dns_a_record"])
                check_type(argname="argument hostname_type", value=hostname_type, expected_type=type_hints["hostname_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enable_resource_name_dns_aaaa_record is not None:
                self._values["enable_resource_name_dns_aaaa_record"] = enable_resource_name_dns_aaaa_record
            if enable_resource_name_dns_a_record is not None:
                self._values["enable_resource_name_dns_a_record"] = enable_resource_name_dns_a_record
            if hostname_type is not None:
                self._values["hostname_type"] = hostname_type

        @builtins.property
        def enable_resource_name_dns_aaaa_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostnames with DNS AAAA records.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privatednsnameoptions.html#cfn-ec2-launchtemplate-privatednsnameoptions-enableresourcenamednsaaaarecord
            '''
            result = self._values.get("enable_resource_name_dns_aaaa_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def enable_resource_name_dns_a_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostnames with DNS A records.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privatednsnameoptions.html#cfn-ec2-launchtemplate-privatednsnameoptions-enableresourcenamednsarecord
            '''
            result = self._values.get("enable_resource_name_dns_a_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def hostname_type(self) -> typing.Optional[builtins.str]:
            '''The type of hostname for EC2 instances.

            For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privatednsnameoptions.html#cfn-ec2-launchtemplate-privatednsnameoptions-hostnametype
            '''
            result = self._values.get("hostname_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateDnsNameOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.PrivateIpAddProperty",
        jsii_struct_bases=[],
        name_mapping={"primary": "primary", "private_ip_address": "privateIpAddress"},
    )
    class PrivateIpAddProperty:
        def __init__(
            self,
            *,
            primary: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            private_ip_address: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a secondary private IPv4 address for a network interface.

            ``PrivateIpAdd`` is a property of `AWS::EC2::LaunchTemplate NetworkInterface <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html>`_ .

            :param primary: Indicates whether the private IPv4 address is the primary private IPv4 address. Only one IPv4 address can be designated as primary.
            :param private_ip_address: The private IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privateipadd.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_ip_add_property = ec2.CfnLaunchTemplate.PrivateIpAddProperty(
                    primary=False,
                    private_ip_address="privateIpAddress"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b6c5b5b228b065f6a57591206bbe516bb3639cfe4572dbb7cedd38475af51917)
                check_type(argname="argument primary", value=primary, expected_type=type_hints["primary"])
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if primary is not None:
                self._values["primary"] = primary
            if private_ip_address is not None:
                self._values["private_ip_address"] = private_ip_address

        @builtins.property
        def primary(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the private IPv4 address is the primary private IPv4 address.

            Only one IPv4 address can be designated as primary.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privateipadd.html#cfn-ec2-launchtemplate-privateipadd-primary
            '''
            result = self._values.get("primary")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def private_ip_address(self) -> typing.Optional[builtins.str]:
            '''The private IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-privateipadd.html#cfn-ec2-launchtemplate-privateipadd-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateIpAddProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.SpotOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "block_duration_minutes": "blockDurationMinutes",
            "instance_interruption_behavior": "instanceInterruptionBehavior",
            "max_price": "maxPrice",
            "spot_instance_type": "spotInstanceType",
            "valid_until": "validUntil",
        },
    )
    class SpotOptionsProperty:
        def __init__(
            self,
            *,
            block_duration_minutes: typing.Optional[jsii.Number] = None,
            instance_interruption_behavior: typing.Optional[builtins.str] = None,
            max_price: typing.Optional[builtins.str] = None,
            spot_instance_type: typing.Optional[builtins.str] = None,
            valid_until: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies options for Spot Instances.

            ``SpotOptions`` is a property of `AWS::EC2::LaunchTemplate InstanceMarketOptions <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-instancemarketoptions.html>`_ .

            :param block_duration_minutes: Deprecated.
            :param instance_interruption_behavior: The behavior when a Spot Instance is interrupted. The default is ``terminate`` .
            :param max_price: The maximum hourly price you're willing to pay for the Spot Instances. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.
            :param spot_instance_type: The Spot Instance request type. If you are using Spot Instances with an Auto Scaling group, use ``one-time`` requests, as the Amazon EC2 Auto Scaling service handles requesting new Spot Instances whenever the group is below its desired capacity.
            :param valid_until: The end date of the request, in UTC format ( *YYYY-MM-DD* T *HH:MM:SS* Z). Supported only for persistent requests. - For a persistent request, the request remains active until the ``ValidUntil`` date and time is reached. Otherwise, the request remains active until you cancel it. - For a one-time request, ``ValidUntil`` is not supported. The request remains active until all instances launch or you cancel the request. Default: 7 days from the current date

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_options_property = ec2.CfnLaunchTemplate.SpotOptionsProperty(
                    block_duration_minutes=123,
                    instance_interruption_behavior="instanceInterruptionBehavior",
                    max_price="maxPrice",
                    spot_instance_type="spotInstanceType",
                    valid_until="validUntil"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6a634ae7e5758becae7a53d5843892730c9c079318bfa3bfc2e89825c3df5db7)
                check_type(argname="argument block_duration_minutes", value=block_duration_minutes, expected_type=type_hints["block_duration_minutes"])
                check_type(argname="argument instance_interruption_behavior", value=instance_interruption_behavior, expected_type=type_hints["instance_interruption_behavior"])
                check_type(argname="argument max_price", value=max_price, expected_type=type_hints["max_price"])
                check_type(argname="argument spot_instance_type", value=spot_instance_type, expected_type=type_hints["spot_instance_type"])
                check_type(argname="argument valid_until", value=valid_until, expected_type=type_hints["valid_until"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if block_duration_minutes is not None:
                self._values["block_duration_minutes"] = block_duration_minutes
            if instance_interruption_behavior is not None:
                self._values["instance_interruption_behavior"] = instance_interruption_behavior
            if max_price is not None:
                self._values["max_price"] = max_price
            if spot_instance_type is not None:
                self._values["spot_instance_type"] = spot_instance_type
            if valid_until is not None:
                self._values["valid_until"] = valid_until

        @builtins.property
        def block_duration_minutes(self) -> typing.Optional[jsii.Number]:
            '''Deprecated.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html#cfn-ec2-launchtemplate-spotoptions-blockdurationminutes
            '''
            result = self._values.get("block_duration_minutes")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def instance_interruption_behavior(self) -> typing.Optional[builtins.str]:
            '''The behavior when a Spot Instance is interrupted.

            The default is ``terminate`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html#cfn-ec2-launchtemplate-spotoptions-instanceinterruptionbehavior
            '''
            result = self._values.get("instance_interruption_behavior")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def max_price(self) -> typing.Optional[builtins.str]:
            '''The maximum hourly price you're willing to pay for the Spot Instances.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html#cfn-ec2-launchtemplate-spotoptions-maxprice
            '''
            result = self._values.get("max_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def spot_instance_type(self) -> typing.Optional[builtins.str]:
            '''The Spot Instance request type.

            If you are using Spot Instances with an Auto Scaling group, use ``one-time`` requests, as the Amazon EC2 Auto Scaling service handles requesting new Spot Instances whenever the group is below its desired capacity.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html#cfn-ec2-launchtemplate-spotoptions-spotinstancetype
            '''
            result = self._values.get("spot_instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def valid_until(self) -> typing.Optional[builtins.str]:
            '''The end date of the request, in UTC format ( *YYYY-MM-DD* T *HH:MM:SS* Z). Supported only for persistent requests.

            - For a persistent request, the request remains active until the ``ValidUntil`` date and time is reached. Otherwise, the request remains active until you cancel it.
            - For a one-time request, ``ValidUntil`` is not supported. The request remains active until all instances launch or you cancel the request.

            Default: 7 days from the current date

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-spotoptions.html#cfn-ec2-launchtemplate-spotoptions-validuntil
            '''
            result = self._values.get("valid_until")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.TagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class TagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies the tags to apply to a resource when the resource is created for the launch template.

            ``TagSpecification`` is a property type of ```TagSpecifications`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-tagspecifications>`_ . ```TagSpecifications`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-tagspecifications>`_ is a property of `AWS::EC2::LaunchTemplate LaunchTemplateData <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html>`_ .

            :param resource_type: The type of resource to tag. Valid Values lists all resource types for Amazon EC2 that can be tagged. When you create a launch template, you can specify tags for the following resource types only: ``instance`` | ``volume`` | ``network-interface`` | ``spot-instances-request`` . If the instance does not include the resource type that you specify, the instance launch fails. For example, not all instance types include a volume. To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ .
            :param tags: The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-tagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                tag_specification_property = ec2.CfnLaunchTemplate.TagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1a8733748f9d5901efa1ec58843b400458e33517cd44b28e33bef4a5872fd248)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource to tag.

            Valid Values lists all resource types for Amazon EC2 that can be tagged. When you create a launch template, you can specify tags for the following resource types only: ``instance`` | ``volume`` | ``network-interface`` | ``spot-instances-request`` . If the instance does not include the resource type that you specify, the instance launch fails. For example, not all instance types include a volume.

            To tag a resource after it has been created, see `CreateTags <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-tagspecification.html#cfn-ec2-launchtemplate-tagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags to apply to the resource.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-tagspecification.html#cfn-ec2-launchtemplate-tagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.TotalLocalStorageGBProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class TotalLocalStorageGBProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total local storage, in GB.

            :param max: The maximum amount of total local storage, in GB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of total local storage, in GB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-totallocalstoragegb.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                total_local_storage_gBProperty = ec2.CfnLaunchTemplate.TotalLocalStorageGBProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8ed29fc8d7249edda98216958a9ce019c183fbac8bedcd813bed77b015d3cc0e)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of total local storage, in GB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-totallocalstoragegb.html#cfn-ec2-launchtemplate-totallocalstoragegb-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of total local storage, in GB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-totallocalstoragegb.html#cfn-ec2-launchtemplate-totallocalstoragegb-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TotalLocalStorageGBProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplate.VCpuCountProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class VCpuCountProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of vCPUs.

            :param max: The maximum number of vCPUs. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of vCPUs. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-vcpucount.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                v_cpu_count_property = ec2.CfnLaunchTemplate.VCpuCountProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__252291d10cb315c45deda9d788d7a3b1df2ea9f0c6cc6c419d2a245bcb858c80)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of vCPUs.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-vcpucount.html#cfn-ec2-launchtemplate-vcpucount-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of vCPUs.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-vcpucount.html#cfn-ec2-launchtemplate-vcpucount-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VCpuCountProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnLaunchTemplateProps",
    jsii_struct_bases=[],
    name_mapping={
        "launch_template_data": "launchTemplateData",
        "launch_template_name": "launchTemplateName",
        "tag_specifications": "tagSpecifications",
        "version_description": "versionDescription",
    },
)
class CfnLaunchTemplateProps:
    def __init__(
        self,
        *,
        launch_template_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateDataProperty, typing.Dict[builtins.str, typing.Any]]],
        launch_template_name: typing.Optional[builtins.str] = None,
        tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        version_description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnLaunchTemplate``.

        :param launch_template_data: The information for the launch template.
        :param launch_template_name: A name for the launch template.
        :param tag_specifications: The tags to apply to the launch template on creation. To tag the launch template, the resource type must be ``launch-template`` . To specify the tags for the resources that are created when an instance is launched, you must use `TagSpecifications <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications>`_ .
        :param version_description: A description for the first version of the launch template.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html
        :exampleMetadata: infused

        Example::

            # cluster: eks.Cluster
            
            
            user_data = """MIME-Version: 1.0
            Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
            
            --==MYBOUNDARY==
            Content-Type: text/x-shellscript; charset="us-ascii"
            
            #!/bin/bash
            echo "Running custom user data script"
            
            --==MYBOUNDARY==--\\
            """
            lt = ec2.CfnLaunchTemplate(self, "LaunchTemplate",
                launch_template_data=ec2.CfnLaunchTemplate.LaunchTemplateDataProperty(
                    instance_type="t3.small",
                    user_data=Fn.base64(user_data)
                )
            )
            
            cluster.add_nodegroup_capacity("extra-ng",
                launch_template_spec=eks.LaunchTemplateSpec(
                    id=lt.ref,
                    version=lt.attr_latest_version_number
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ec8b981d02ac258969e05ce7585fd8bc6c8a75db9044f873a95758a20fff70e)
            check_type(argname="argument launch_template_data", value=launch_template_data, expected_type=type_hints["launch_template_data"])
            check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
            check_type(argname="argument version_description", value=version_description, expected_type=type_hints["version_description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "launch_template_data": launch_template_data,
        }
        if launch_template_name is not None:
            self._values["launch_template_name"] = launch_template_name
        if tag_specifications is not None:
            self._values["tag_specifications"] = tag_specifications
        if version_description is not None:
            self._values["version_description"] = version_description

    @builtins.property
    def launch_template_data(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateDataProperty]:
        '''The information for the launch template.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-launchtemplatedata
        '''
        result = self._values.get("launch_template_data")
        assert result is not None, "Required property 'launch_template_data' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateDataProperty], result)

    @builtins.property
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''A name for the launch template.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-launchtemplatename
        '''
        result = self._values.get("launch_template_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tag_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty]]]]:
        '''The tags to apply to the launch template on creation.

        To tag the launch template, the resource type must be ``launch-template`` .

        To specify the tags for the resources that are created when an instance is launched, you must use `TagSpecifications <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-tagspecifications
        '''
        result = self._values.get("tag_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty]]]], result)

    @builtins.property
    def version_description(self) -> typing.Optional[builtins.str]:
        '''A description for the first version of the launch template.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-versiondescription
        '''
        result = self._values.get("version_description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnLaunchTemplateProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnLocalGatewayRoute(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRoute",
):
    '''Creates a static route for the specified local gateway route table. You must specify one of the following targets:.

    - ``LocalGatewayVirtualInterfaceGroupId``
    - ``NetworkInterfaceId``

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html
    :cloudformationResource: AWS::EC2::LocalGatewayRoute
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_local_gateway_route = ec2.CfnLocalGatewayRoute(self, "MyCfnLocalGatewayRoute",
            destination_cidr_block="destinationCidrBlock",
            local_gateway_route_table_id="localGatewayRouteTableId",
        
            # the properties below are optional
            local_gateway_virtual_interface_group_id="localGatewayVirtualInterfaceGroupId",
            network_interface_id="networkInterfaceId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        destination_cidr_block: builtins.str,
        local_gateway_route_table_id: builtins.str,
        local_gateway_virtual_interface_group_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param destination_cidr_block: The CIDR block used for destination matches.
        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param local_gateway_virtual_interface_group_id: The ID of the virtual interface group.
        :param network_interface_id: The ID of the network interface.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72620c57e4f2bf7a9115eae14683be82615679dd719de82cc89cf920ca09c958)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnLocalGatewayRouteProps(
            destination_cidr_block=destination_cidr_block,
            local_gateway_route_table_id=local_gateway_route_table_id,
            local_gateway_virtual_interface_group_id=local_gateway_virtual_interface_group_id,
            network_interface_id=network_interface_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ffe9c938b1e0b72a3aa305a264527da086b8a6bed3d2cb3286d8eabfdbe3f824)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec50537d152eff5a7daafd07e093cb27e49e3d0993280375144ce053cf2402a5)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the local gateway route table.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="attrType")
    def attr_type(self) -> builtins.str:
        '''The type of local gateway route.

        :cloudformationAttribute: Type
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrType"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> builtins.str:
        '''The CIDR block used for destination matches.'''
        return typing.cast(builtins.str, jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__284f7bbdd38f7ad3348c9044b6b38e1a9461b65412f2de7bd853d0585652ad97)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="localGatewayRouteTableId")
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.'''
        return typing.cast(builtins.str, jsii.get(self, "localGatewayRouteTableId"))

    @local_gateway_route_table_id.setter
    def local_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__258fe4e66c64168f5e44e5f2492626784b284fa6f780e59ed909875e94b39e09)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="localGatewayVirtualInterfaceGroupId")
    def local_gateway_virtual_interface_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual interface group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "localGatewayVirtualInterfaceGroupId"))

    @local_gateway_virtual_interface_group_id.setter
    def local_gateway_virtual_interface_group_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58fa103093c5183e7f8dafe5b8c276c2282b2b68eb80103a08c264405ff5d125)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayVirtualInterfaceGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the network interface.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bbdbb6e7afc1da4e3b78d537bfd48cd4ca542e7f284abad2c00f60672ea08b56)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteProps",
    jsii_struct_bases=[],
    name_mapping={
        "destination_cidr_block": "destinationCidrBlock",
        "local_gateway_route_table_id": "localGatewayRouteTableId",
        "local_gateway_virtual_interface_group_id": "localGatewayVirtualInterfaceGroupId",
        "network_interface_id": "networkInterfaceId",
    },
)
class CfnLocalGatewayRouteProps:
    def __init__(
        self,
        *,
        destination_cidr_block: builtins.str,
        local_gateway_route_table_id: builtins.str,
        local_gateway_virtual_interface_group_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnLocalGatewayRoute``.

        :param destination_cidr_block: The CIDR block used for destination matches.
        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param local_gateway_virtual_interface_group_id: The ID of the virtual interface group.
        :param network_interface_id: The ID of the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_local_gateway_route_props = ec2.CfnLocalGatewayRouteProps(
                destination_cidr_block="destinationCidrBlock",
                local_gateway_route_table_id="localGatewayRouteTableId",
            
                # the properties below are optional
                local_gateway_virtual_interface_group_id="localGatewayVirtualInterfaceGroupId",
                network_interface_id="networkInterfaceId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__499c08d2030590469c3f75c2db0ccbf56b55e3c8147f40f2deae8d51f1e16ea8)
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument local_gateway_route_table_id", value=local_gateway_route_table_id, expected_type=type_hints["local_gateway_route_table_id"])
            check_type(argname="argument local_gateway_virtual_interface_group_id", value=local_gateway_virtual_interface_group_id, expected_type=type_hints["local_gateway_virtual_interface_group_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "destination_cidr_block": destination_cidr_block,
            "local_gateway_route_table_id": local_gateway_route_table_id,
        }
        if local_gateway_virtual_interface_group_id is not None:
            self._values["local_gateway_virtual_interface_group_id"] = local_gateway_virtual_interface_group_id
        if network_interface_id is not None:
            self._values["network_interface_id"] = network_interface_id

    @builtins.property
    def destination_cidr_block(self) -> builtins.str:
        '''The CIDR block used for destination matches.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html#cfn-ec2-localgatewayroute-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        assert result is not None, "Required property 'destination_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html#cfn-ec2-localgatewayroute-localgatewayroutetableid
        '''
        result = self._values.get("local_gateway_route_table_id")
        assert result is not None, "Required property 'local_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def local_gateway_virtual_interface_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual interface group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html#cfn-ec2-localgatewayroute-localgatewayvirtualinterfacegroupid
        '''
        result = self._values.get("local_gateway_virtual_interface_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroute.html#cfn-ec2-localgatewayroute-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnLocalGatewayRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnLocalGatewayRouteTable(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTable",
):
    '''Describes a local gateway route table.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetable.html
    :cloudformationResource: AWS::EC2::LocalGatewayRouteTable
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_local_gateway_route_table = ec2.CfnLocalGatewayRouteTable(self, "MyCfnLocalGatewayRouteTable",
            local_gateway_id="localGatewayId",
        
            # the properties below are optional
            mode="mode",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        local_gateway_id: builtins.str,
        mode: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param local_gateway_id: The ID of the local gateway.
        :param mode: The mode of the local gateway route table.
        :param tags: The tags assigned to the local gateway route table.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0f9c82b014b2cf996c944f8ac77dfcd714445f9325eb729e49261180925b4fce)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnLocalGatewayRouteTableProps(
            local_gateway_id=local_gateway_id, mode=mode, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d8e1134467f7e2d3e7c98d1c34ed6355acd715a1e19e8c325fcfe3629c6ddf4)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11527c45dd2e02ff7288c3b23407a02e25a092dc692463ba416672732323c71d)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayRouteTableArn")
    def attr_local_gateway_route_table_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the local gateway route table.

        :cloudformationAttribute: LocalGatewayRouteTableArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayRouteTableArn"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayRouteTableId")
    def attr_local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.

        :cloudformationAttribute: LocalGatewayRouteTableId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayRouteTableId"))

    @builtins.property
    @jsii.member(jsii_name="attrOutpostArn")
    def attr_outpost_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the Outpost.

        :cloudformationAttribute: OutpostArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOutpostArn"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The ID of the AWS account that owns the local gateway route table.

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the local gateway route table.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="localGatewayId")
    def local_gateway_id(self) -> builtins.str:
        '''The ID of the local gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "localGatewayId"))

    @local_gateway_id.setter
    def local_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8764135c1641b2203523cd33942af3fa2e31344ecb511bebe4ca29d5cae31d70)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="mode")
    def mode(self) -> typing.Optional[builtins.str]:
        '''The mode of the local gateway route table.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "mode"))

    @mode.setter
    def mode(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e6d522d98a8fb40061031263e05658588786d15d85756c082a90c6ce0f56420)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "mode", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the local gateway route table.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__474f4bbd5ed57b4f72353a6d5ffc02e911411af536dcda10d9ff19641235d875)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTableProps",
    jsii_struct_bases=[],
    name_mapping={
        "local_gateway_id": "localGatewayId",
        "mode": "mode",
        "tags": "tags",
    },
)
class CfnLocalGatewayRouteTableProps:
    def __init__(
        self,
        *,
        local_gateway_id: builtins.str,
        mode: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnLocalGatewayRouteTable``.

        :param local_gateway_id: The ID of the local gateway.
        :param mode: The mode of the local gateway route table.
        :param tags: The tags assigned to the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetable.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_local_gateway_route_table_props = ec2.CfnLocalGatewayRouteTableProps(
                local_gateway_id="localGatewayId",
            
                # the properties below are optional
                mode="mode",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b2df322e30dde560e72dd45e268c9483dfa622c0994e547c0799f7ab18ee4290)
            check_type(argname="argument local_gateway_id", value=local_gateway_id, expected_type=type_hints["local_gateway_id"])
            check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "local_gateway_id": local_gateway_id,
        }
        if mode is not None:
            self._values["mode"] = mode
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def local_gateway_id(self) -> builtins.str:
        '''The ID of the local gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetable.html#cfn-ec2-localgatewayroutetable-localgatewayid
        '''
        result = self._values.get("local_gateway_id")
        assert result is not None, "Required property 'local_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def mode(self) -> typing.Optional[builtins.str]:
        '''The mode of the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetable.html#cfn-ec2-localgatewayroutetable-mode
        '''
        result = self._values.get("mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetable.html#cfn-ec2-localgatewayroutetable-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnLocalGatewayRouteTableProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnLocalGatewayRouteTableVPCAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTableVPCAssociation",
):
    '''Associates the specified VPC with the specified local gateway route table.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevpcassociation.html
    :cloudformationResource: AWS::EC2::LocalGatewayRouteTableVPCAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_local_gateway_route_table_vPCAssociation = ec2.CfnLocalGatewayRouteTableVPCAssociation(self, "MyCfnLocalGatewayRouteTableVPCAssociation",
            local_gateway_route_table_id="localGatewayRouteTableId",
            vpc_id="vpcId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        local_gateway_route_table_id: builtins.str,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param vpc_id: The ID of the VPC.
        :param tags: The tags assigned to the association.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__942279fba690e3b98e5f34e81caaa9a7615238fc515203fa1334212075896e41)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnLocalGatewayRouteTableVPCAssociationProps(
            local_gateway_route_table_id=local_gateway_route_table_id,
            vpc_id=vpc_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e0090cdfca64ec4d1bbfb0e79bc4d70ac0e16c0b41e3d5a4f6379764eab22fd)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__795bf2d5ebe3651ebff429b9ef1073cafa616dacbc61ad7f7cad5996d170ad93)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayId")
    def attr_local_gateway_id(self) -> builtins.str:
        '''The ID of the local gateway.

        :cloudformationAttribute: LocalGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayRouteTableVpcAssociationId")
    def attr_local_gateway_route_table_vpc_association_id(self) -> builtins.str:
        '''The ID of the association.

        :cloudformationAttribute: LocalGatewayRouteTableVpcAssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayRouteTableVpcAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the association.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="localGatewayRouteTableId")
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.'''
        return typing.cast(builtins.str, jsii.get(self, "localGatewayRouteTableId"))

    @local_gateway_route_table_id.setter
    def local_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f0258f30ef32e65ee0ff90cd3702b03aa634686401498bd56f0216eca60f0cef)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efc5db4ad316c716028acffc99962fb18c3565a9230f9c7a4ac17013a396d7f3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the association.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8dc2642e9ef0df7fa52a5ba86e739132e5d4c9e28888baf78dfe07b4db11a6a0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTableVPCAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "local_gateway_route_table_id": "localGatewayRouteTableId",
        "vpc_id": "vpcId",
        "tags": "tags",
    },
)
class CfnLocalGatewayRouteTableVPCAssociationProps:
    def __init__(
        self,
        *,
        local_gateway_route_table_id: builtins.str,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnLocalGatewayRouteTableVPCAssociation``.

        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param vpc_id: The ID of the VPC.
        :param tags: The tags assigned to the association.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevpcassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_local_gateway_route_table_vPCAssociation_props = ec2.CfnLocalGatewayRouteTableVPCAssociationProps(
                local_gateway_route_table_id="localGatewayRouteTableId",
                vpc_id="vpcId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5c48f6b8e9634782c4f69b39340ebe9aa71051648046f1ad204ad1816bb18e6c)
            check_type(argname="argument local_gateway_route_table_id", value=local_gateway_route_table_id, expected_type=type_hints["local_gateway_route_table_id"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "local_gateway_route_table_id": local_gateway_route_table_id,
            "vpc_id": vpc_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevpcassociation.html#cfn-ec2-localgatewayroutetablevpcassociation-localgatewayroutetableid
        '''
        result = self._values.get("local_gateway_route_table_id")
        assert result is not None, "Required property 'local_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevpcassociation.html#cfn-ec2-localgatewayroutetablevpcassociation-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the association.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevpcassociation.html#cfn-ec2-localgatewayroutetablevpcassociation-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnLocalGatewayRouteTableVPCAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
):
    '''Describes an association between a local gateway route table and a virtual interface group.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevirtualinterfacegroupassociation.html
    :cloudformationResource: AWS::EC2::LocalGatewayRouteTableVirtualInterfaceGroupAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_local_gateway_route_table_virtual_interface_group_association = ec2.CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation(self, "MyCfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
            local_gateway_route_table_id="localGatewayRouteTableId",
            local_gateway_virtual_interface_group_id="localGatewayVirtualInterfaceGroupId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        local_gateway_route_table_id: builtins.str,
        local_gateway_virtual_interface_group_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param local_gateway_virtual_interface_group_id: The ID of the virtual interface group.
        :param tags: The tags assigned to the association.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50c4489e5740fab22081ddb54e3174bf9ad508e11ecbc13eefa82b53a4ebd282)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps(
            local_gateway_route_table_id=local_gateway_route_table_id,
            local_gateway_virtual_interface_group_id=local_gateway_virtual_interface_group_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d39418274eaeb02fc75ac2865586ff6b8ebd16a2cc61f6e8185359a87240a1f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a2e78d77a54b43dfe60da90fb91dfabd471092e95b875c27577371d55122d581)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayId")
    def attr_local_gateway_id(self) -> builtins.str:
        '''The ID of the local gateway.

        :cloudformationAttribute: LocalGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayRouteTableArn")
    def attr_local_gateway_route_table_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the local gateway route table for the virtual interface group.

        :cloudformationAttribute: LocalGatewayRouteTableArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayRouteTableArn"))

    @builtins.property
    @jsii.member(jsii_name="attrLocalGatewayRouteTableVirtualInterfaceGroupAssociationId")
    def attr_local_gateway_route_table_virtual_interface_group_association_id(
        self,
    ) -> builtins.str:
        '''The ID of the association.

        :cloudformationAttribute: LocalGatewayRouteTableVirtualInterfaceGroupAssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLocalGatewayRouteTableVirtualInterfaceGroupAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The ID of the AWS account that owns the local gateway virtual interface group association.

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the association.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="localGatewayRouteTableId")
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.'''
        return typing.cast(builtins.str, jsii.get(self, "localGatewayRouteTableId"))

    @local_gateway_route_table_id.setter
    def local_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00b8900032b020c8ecf3731ad9c656b7d99ff96247651f6db8828e7db8333ff7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="localGatewayVirtualInterfaceGroupId")
    def local_gateway_virtual_interface_group_id(self) -> builtins.str:
        '''The ID of the virtual interface group.'''
        return typing.cast(builtins.str, jsii.get(self, "localGatewayVirtualInterfaceGroupId"))

    @local_gateway_virtual_interface_group_id.setter
    def local_gateway_virtual_interface_group_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a41b6fdc992ef23b49578301926d25be90e610be1c62ae942896516610f7e461)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayVirtualInterfaceGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the association.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3480fc1fb89ce602f4bc2bf15c99da71be91c04a233e81dcafb2795f1355c034)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "local_gateway_route_table_id": "localGatewayRouteTableId",
        "local_gateway_virtual_interface_group_id": "localGatewayVirtualInterfaceGroupId",
        "tags": "tags",
    },
)
class CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps:
    def __init__(
        self,
        *,
        local_gateway_route_table_id: builtins.str,
        local_gateway_virtual_interface_group_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation``.

        :param local_gateway_route_table_id: The ID of the local gateway route table.
        :param local_gateway_virtual_interface_group_id: The ID of the virtual interface group.
        :param tags: The tags assigned to the association.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevirtualinterfacegroupassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_local_gateway_route_table_virtual_interface_group_association_props = ec2.CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps(
                local_gateway_route_table_id="localGatewayRouteTableId",
                local_gateway_virtual_interface_group_id="localGatewayVirtualInterfaceGroupId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b9a8cd9288a52b6663080797430bf0981183639ee7ad7887a7ff932d017714e9)
            check_type(argname="argument local_gateway_route_table_id", value=local_gateway_route_table_id, expected_type=type_hints["local_gateway_route_table_id"])
            check_type(argname="argument local_gateway_virtual_interface_group_id", value=local_gateway_virtual_interface_group_id, expected_type=type_hints["local_gateway_virtual_interface_group_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "local_gateway_route_table_id": local_gateway_route_table_id,
            "local_gateway_virtual_interface_group_id": local_gateway_virtual_interface_group_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def local_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the local gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevirtualinterfacegroupassociation.html#cfn-ec2-localgatewayroutetablevirtualinterfacegroupassociation-localgatewayroutetableid
        '''
        result = self._values.get("local_gateway_route_table_id")
        assert result is not None, "Required property 'local_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def local_gateway_virtual_interface_group_id(self) -> builtins.str:
        '''The ID of the virtual interface group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevirtualinterfacegroupassociation.html#cfn-ec2-localgatewayroutetablevirtualinterfacegroupassociation-localgatewayvirtualinterfacegroupid
        '''
        result = self._values.get("local_gateway_virtual_interface_group_id")
        assert result is not None, "Required property 'local_gateway_virtual_interface_group_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags assigned to the association.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-localgatewayroutetablevirtualinterfacegroupassociation.html#cfn-ec2-localgatewayroutetablevirtualinterfacegroupassociation-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNatGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNatGateway",
):
    '''Specifies a network address translation (NAT) gateway in the specified subnet.

    You can create either a public NAT gateway or a private NAT gateway. The default is a public NAT gateway. If you create a public NAT gateway, you must specify an elastic IP address.

    With a NAT gateway, instances in a private subnet can connect to the internet, other AWS services, or an on-premises network using the IP address of the NAT gateway. For more information, see `NAT gateways <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html>`_ in the *Amazon VPC User Guide* .

    If you add a default route ( ``AWS::EC2::Route`` resource) that points to a NAT gateway, specify the NAT gateway ID for the route's ``NatGatewayId`` property.
    .. epigraph::

       When you associate an Elastic IP address or secondary Elastic IP address with a public NAT gateway, the network border group of the Elastic IP address must match the network border group of the Availability Zone (AZ) that the public NAT gateway is in. Otherwise, the NAT gateway fails to launch. You can see the network border group for the AZ by viewing the details of the subnet. Similarly, you can view the network border group for the Elastic IP address by viewing its details. For more information, see `Allocate an Elastic IP address <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#allocate-eip>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html
    :cloudformationResource: AWS::EC2::NatGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_nat_gateway = ec2.CfnNatGateway(self, "MyCfnNatGateway",
            subnet_id="subnetId",
        
            # the properties below are optional
            allocation_id="allocationId",
            connectivity_type="connectivityType",
            max_drain_duration_seconds=123,
            private_ip_address="privateIpAddress",
            secondary_allocation_ids=["secondaryAllocationIds"],
            secondary_private_ip_address_count=123,
            secondary_private_ip_addresses=["secondaryPrivateIpAddresses"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        allocation_id: typing.Optional[builtins.str] = None,
        connectivity_type: typing.Optional[builtins.str] = None,
        max_drain_duration_seconds: typing.Optional[jsii.Number] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        secondary_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
        secondary_private_ip_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_id: The ID of the subnet in which the NAT gateway is located.
        :param allocation_id: [Public NAT gateway only] The allocation ID of the Elastic IP address that's associated with the NAT gateway. This property is required for a public NAT gateway and cannot be specified with a private NAT gateway.
        :param connectivity_type: Indicates whether the NAT gateway supports public or private connectivity. The default is public connectivity.
        :param max_drain_duration_seconds: The maximum amount of time to wait (in seconds) before forcibly releasing the IP addresses if connections are still in progress. Default value is 350 seconds.
        :param private_ip_address: The private IPv4 address to assign to the NAT gateway. If you don't provide an address, a private IPv4 address will be automatically assigned.
        :param secondary_allocation_ids: Secondary EIP allocation IDs. For more information, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon VPC User Guide* .
        :param secondary_private_ip_address_count: [Private NAT gateway only] The number of secondary private IPv4 addresses you want to assign to the NAT gateway. For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* . ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.
        :param secondary_private_ip_addresses: Secondary private IPv4 addresses. For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* . ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.
        :param tags: The tags for the NAT gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d23f1a46df0174ce142c0ff05ac9cb901ecac30141c8b466b44569b409414aa)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNatGatewayProps(
            subnet_id=subnet_id,
            allocation_id=allocation_id,
            connectivity_type=connectivity_type,
            max_drain_duration_seconds=max_drain_duration_seconds,
            private_ip_address=private_ip_address,
            secondary_allocation_ids=secondary_allocation_ids,
            secondary_private_ip_address_count=secondary_private_ip_address_count,
            secondary_private_ip_addresses=secondary_private_ip_addresses,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdb247dbf854f85e48e3d293459592f7c17817fd538cc790bbc2b953d197c893)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ccb9afd936b7ea3bdc26e449176215293a7150d149aecacc164a3b752bff21c8)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrNatGatewayId")
    def attr_nat_gateway_id(self) -> builtins.str:
        '''The ID of the NAT gateway.

        :cloudformationAttribute: NatGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNatGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet in which the NAT gateway is located.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ea5b3187b853cfa340b72b2a61dc1a1d7320459e754c328fc7013f403d31c74)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="allocationId")
    def allocation_id(self) -> typing.Optional[builtins.str]:
        '''[Public NAT gateway only] The allocation ID of the Elastic IP address that's associated with the NAT gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "allocationId"))

    @allocation_id.setter
    def allocation_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4cfe702c80e90b7e94df290ccbd9b1126a59f7167ee8d0b08ead001f4b760be)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allocationId", value)

    @builtins.property
    @jsii.member(jsii_name="connectivityType")
    def connectivity_type(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the NAT gateway supports public or private connectivity.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "connectivityType"))

    @connectivity_type.setter
    def connectivity_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__876ad6282ee6cb51d07bc9ad188a0cd1b3e56f76eeb223668608b35ad422b23a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connectivityType", value)

    @builtins.property
    @jsii.member(jsii_name="maxDrainDurationSeconds")
    def max_drain_duration_seconds(self) -> typing.Optional[jsii.Number]:
        '''The maximum amount of time to wait (in seconds) before forcibly releasing the IP addresses if connections are still in progress.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "maxDrainDurationSeconds"))

    @max_drain_duration_seconds.setter
    def max_drain_duration_seconds(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d27a75587aef8f41874e3425910acc61091eb1d6163f756677bc9a4cf75abb5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "maxDrainDurationSeconds", value)

    @builtins.property
    @jsii.member(jsii_name="privateIpAddress")
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The private IPv4 address to assign to the NAT gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "privateIpAddress"))

    @private_ip_address.setter
    def private_ip_address(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6537dd3590fc4a352eb713faffc379d97706a253c00d5712e19a55f55b2e0f35)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateIpAddress", value)

    @builtins.property
    @jsii.member(jsii_name="secondaryAllocationIds")
    def secondary_allocation_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Secondary EIP allocation IDs.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "secondaryAllocationIds"))

    @secondary_allocation_ids.setter
    def secondary_allocation_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f9000fd8f77350e1a52d17cbdb7cc11f37c348d2f5717255745539ee5d28f56)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "secondaryAllocationIds", value)

    @builtins.property
    @jsii.member(jsii_name="secondaryPrivateIpAddressCount")
    def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
        '''[Private NAT gateway only] The number of secondary private IPv4 addresses you want to assign to the NAT gateway.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "secondaryPrivateIpAddressCount"))

    @secondary_private_ip_address_count.setter
    def secondary_private_ip_address_count(
        self,
        value: typing.Optional[jsii.Number],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f19a6be27e712f51611c6896aa7f080c172150b391298495387ab2307eecd23)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "secondaryPrivateIpAddressCount", value)

    @builtins.property
    @jsii.member(jsii_name="secondaryPrivateIpAddresses")
    def secondary_private_ip_addresses(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''Secondary private IPv4 addresses.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "secondaryPrivateIpAddresses"))

    @secondary_private_ip_addresses.setter
    def secondary_private_ip_addresses(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f95c2f3e513b379e30162aef0ef12684ffddc3d711e6a83303fbb920f2f3487)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "secondaryPrivateIpAddresses", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the NAT gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76a6a3daaab575df04de03efcf802de9ee1357d57a0474a96922bc7d42b638e2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNatGatewayProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "allocation_id": "allocationId",
        "connectivity_type": "connectivityType",
        "max_drain_duration_seconds": "maxDrainDurationSeconds",
        "private_ip_address": "privateIpAddress",
        "secondary_allocation_ids": "secondaryAllocationIds",
        "secondary_private_ip_address_count": "secondaryPrivateIpAddressCount",
        "secondary_private_ip_addresses": "secondaryPrivateIpAddresses",
        "tags": "tags",
    },
)
class CfnNatGatewayProps:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        allocation_id: typing.Optional[builtins.str] = None,
        connectivity_type: typing.Optional[builtins.str] = None,
        max_drain_duration_seconds: typing.Optional[jsii.Number] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        secondary_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
        secondary_private_ip_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNatGateway``.

        :param subnet_id: The ID of the subnet in which the NAT gateway is located.
        :param allocation_id: [Public NAT gateway only] The allocation ID of the Elastic IP address that's associated with the NAT gateway. This property is required for a public NAT gateway and cannot be specified with a private NAT gateway.
        :param connectivity_type: Indicates whether the NAT gateway supports public or private connectivity. The default is public connectivity.
        :param max_drain_duration_seconds: The maximum amount of time to wait (in seconds) before forcibly releasing the IP addresses if connections are still in progress. Default value is 350 seconds.
        :param private_ip_address: The private IPv4 address to assign to the NAT gateway. If you don't provide an address, a private IPv4 address will be automatically assigned.
        :param secondary_allocation_ids: Secondary EIP allocation IDs. For more information, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon VPC User Guide* .
        :param secondary_private_ip_address_count: [Private NAT gateway only] The number of secondary private IPv4 addresses you want to assign to the NAT gateway. For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* . ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.
        :param secondary_private_ip_addresses: Secondary private IPv4 addresses. For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* . ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.
        :param tags: The tags for the NAT gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_nat_gateway_props = ec2.CfnNatGatewayProps(
                subnet_id="subnetId",
            
                # the properties below are optional
                allocation_id="allocationId",
                connectivity_type="connectivityType",
                max_drain_duration_seconds=123,
                private_ip_address="privateIpAddress",
                secondary_allocation_ids=["secondaryAllocationIds"],
                secondary_private_ip_address_count=123,
                secondary_private_ip_addresses=["secondaryPrivateIpAddresses"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1aba83edf7a8e3f14e1d4f9ca76c7049f7f7c569d2ffb43bcad65b330ee9a581)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument allocation_id", value=allocation_id, expected_type=type_hints["allocation_id"])
            check_type(argname="argument connectivity_type", value=connectivity_type, expected_type=type_hints["connectivity_type"])
            check_type(argname="argument max_drain_duration_seconds", value=max_drain_duration_seconds, expected_type=type_hints["max_drain_duration_seconds"])
            check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            check_type(argname="argument secondary_allocation_ids", value=secondary_allocation_ids, expected_type=type_hints["secondary_allocation_ids"])
            check_type(argname="argument secondary_private_ip_address_count", value=secondary_private_ip_address_count, expected_type=type_hints["secondary_private_ip_address_count"])
            check_type(argname="argument secondary_private_ip_addresses", value=secondary_private_ip_addresses, expected_type=type_hints["secondary_private_ip_addresses"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if allocation_id is not None:
            self._values["allocation_id"] = allocation_id
        if connectivity_type is not None:
            self._values["connectivity_type"] = connectivity_type
        if max_drain_duration_seconds is not None:
            self._values["max_drain_duration_seconds"] = max_drain_duration_seconds
        if private_ip_address is not None:
            self._values["private_ip_address"] = private_ip_address
        if secondary_allocation_ids is not None:
            self._values["secondary_allocation_ids"] = secondary_allocation_ids
        if secondary_private_ip_address_count is not None:
            self._values["secondary_private_ip_address_count"] = secondary_private_ip_address_count
        if secondary_private_ip_addresses is not None:
            self._values["secondary_private_ip_addresses"] = secondary_private_ip_addresses
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet in which the NAT gateway is located.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def allocation_id(self) -> typing.Optional[builtins.str]:
        '''[Public NAT gateway only] The allocation ID of the Elastic IP address that's associated with the NAT gateway.

        This property is required for a public NAT gateway and cannot be specified with a private NAT gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-allocationid
        '''
        result = self._values.get("allocation_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def connectivity_type(self) -> typing.Optional[builtins.str]:
        '''Indicates whether the NAT gateway supports public or private connectivity.

        The default is public connectivity.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-connectivitytype
        '''
        result = self._values.get("connectivity_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_drain_duration_seconds(self) -> typing.Optional[jsii.Number]:
        '''The maximum amount of time to wait (in seconds) before forcibly releasing the IP addresses if connections are still in progress.

        Default value is 350 seconds.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-maxdraindurationseconds
        '''
        result = self._values.get("max_drain_duration_seconds")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''The private IPv4 address to assign to the NAT gateway.

        If you don't provide an address, a private IPv4 address will be automatically assigned.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-privateipaddress
        '''
        result = self._values.get("private_ip_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def secondary_allocation_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Secondary EIP allocation IDs.

        For more information, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon VPC User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-secondaryallocationids
        '''
        result = self._values.get("secondary_allocation_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
        '''[Private NAT gateway only] The number of secondary private IPv4 addresses you want to assign to the NAT gateway.

        For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* .

        ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-secondaryprivateipaddresscount
        '''
        result = self._values.get("secondary_private_ip_address_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def secondary_private_ip_addresses(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''Secondary private IPv4 addresses.

        For more information about secondary addresses, see `Create a NAT gateway <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-creating>`_ in the *Amazon Virtual Private Cloud User Guide* .

        ``SecondaryPrivateIpAddressCount`` and ``SecondaryPrivateIpAddresses`` cannot be set at the same time.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-secondaryprivateipaddresses
        '''
        result = self._values.get("secondary_private_ip_addresses")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the NAT gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html#cfn-ec2-natgateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNatGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkAcl(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAcl",
):
    '''Specifies a network ACL for your VPC.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkacl.html
    :cloudformationResource: AWS::EC2::NetworkAcl
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_acl = ec2.CfnNetworkAcl(self, "MyCfnNetworkAcl",
            vpc_id="vpcId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC for the network ACL.
        :param tags: The tags for the network ACL.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__63ab91eb0620cbae6ae1a944345b6c561c70134e58fe810193ad3be248faf08e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkAclProps(vpc_id=vpc_id, tags=tags)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe39a240a6d0a1f329485e9ae7a28d0cd7945ff27d2505d051744187043eb6d1)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__66ec96ce0ad1840d07255ec22b8f5655663f6004c4dadfe16518083ec35f8ec1)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the network ACL.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC for the network ACL.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__601d1eecd1d541ed4359648f8987e7f0c1586ee8c30a428d2784f12903f027b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the network ACL.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57b49669fc82f61a0619b6f81ea70040da2911bd088956733571d0ccefef92a3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.implements(_IInspectable_c2943556)
class CfnNetworkAclEntry(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAclEntry",
):
    '''Specifies an entry, known as a rule, in a network ACL with a rule number you specify.

    Each network ACL has a set of numbered ingress rules and a separate set of numbered egress rules.

    For information about the protocol value, see `Protocol Numbers <https://docs.aws.amazon.com/https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ on the Internet Assigned Numbers Authority (IANA) website.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html
    :cloudformationResource: AWS::EC2::NetworkAclEntry
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_acl_entry = ec2.CfnNetworkAclEntry(self, "MyCfnNetworkAclEntry",
            network_acl_id="networkAclId",
            protocol=123,
            rule_action="ruleAction",
            rule_number=123,
        
            # the properties below are optional
            cidr_block="cidrBlock",
            egress=False,
            icmp=ec2.CfnNetworkAclEntry.IcmpProperty(
                code=123,
                type=123
            ),
            ipv6_cidr_block="ipv6CidrBlock",
            port_range=ec2.CfnNetworkAclEntry.PortRangeProperty(
                from=123,
                to=123
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_acl_id: builtins.str,
        protocol: jsii.Number,
        rule_action: builtins.str,
        rule_number: jsii.Number,
        cidr_block: typing.Optional[builtins.str] = None,
        egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        icmp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkAclEntry.IcmpProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkAclEntry.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param network_acl_id: The ID of the ACL for the entry.
        :param protocol: The IP protocol that the rule applies to. You must specify -1 or a protocol number. You can specify -1 for all protocols. .. epigraph:: If you specify -1, all ports are opened and the ``PortRange`` property is ignored.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny".
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param cidr_block: The IPv4 CIDR range to allow or deny, in CIDR notation (for example, 172.16.0.0/24). You must specify an IPv4 CIDR block or an IPv6 CIDR block.
        :param egress: Whether this rule applies to egress traffic from the subnet ( ``true`` ) or ingress traffic to the subnet ( ``false`` ). By default, AWS CloudFormation specifies ``false`` .
        :param icmp: The Internet Control Message Protocol (ICMP) code and type. Required if specifying 1 (ICMP) for the protocol parameter.
        :param ipv6_cidr_block: The IPv6 network range to allow or deny, in CIDR notation. You must specify an IPv4 CIDR block or an IPv6 CIDR block.
        :param port_range: The range of port numbers for the UDP/TCP protocol. Required if specifying 6 (TCP) or 17 (UDP) for the protocol parameter.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19a17fef3fa11c116781af713a02917ffb22907292ed07e600fbabfb34ff85aa)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkAclEntryProps(
            network_acl_id=network_acl_id,
            protocol=protocol,
            rule_action=rule_action,
            rule_number=rule_number,
            cidr_block=cidr_block,
            egress=egress,
            icmp=icmp,
            ipv6_cidr_block=ipv6_cidr_block,
            port_range=port_range,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f78b787a243fda4583b640a047854d253c8571e9d307cc5ceafe477c1745b178)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb01dc92902461a71fc556995b03455fed5965d2b1548f2381bc82b583b4bcb8)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the network ACL entry.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="networkAclId")
    def network_acl_id(self) -> builtins.str:
        '''The ID of the ACL for the entry.'''
        return typing.cast(builtins.str, jsii.get(self, "networkAclId"))

    @network_acl_id.setter
    def network_acl_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5588a9e32b91ce07908bc6161c70a3321011b4a40f6187709a1b19411233a82a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkAclId", value)

    @builtins.property
    @jsii.member(jsii_name="protocol")
    def protocol(self) -> jsii.Number:
        '''The IP protocol that the rule applies to.'''
        return typing.cast(jsii.Number, jsii.get(self, "protocol"))

    @protocol.setter
    def protocol(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86505e85738323ea818a1610435eace033b1dd92450cde0e2051dddc6e425d81)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "protocol", value)

    @builtins.property
    @jsii.member(jsii_name="ruleAction")
    def rule_action(self) -> builtins.str:
        '''Whether to allow or deny traffic that matches the rule;'''
        return typing.cast(builtins.str, jsii.get(self, "ruleAction"))

    @rule_action.setter
    def rule_action(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c4c19a5c3c4f835d900da5c3a7da29b7dae9ed72ede397df02aa3b5e5dbc7c2c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ruleAction", value)

    @builtins.property
    @jsii.member(jsii_name="ruleNumber")
    def rule_number(self) -> jsii.Number:
        '''Rule number to assign to the entry, such as 100.'''
        return typing.cast(jsii.Number, jsii.get(self, "ruleNumber"))

    @rule_number.setter
    def rule_number(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__254c3e7afcaa640549a034dcc005709b57dcf456e261c0a220d284c9390f74c0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ruleNumber", value)

    @builtins.property
    @jsii.member(jsii_name="cidrBlock")
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR range to allow or deny, in CIDR notation (for example, 172.16.0.0/24). You must specify an IPv4 CIDR block or an IPv6 CIDR block.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrBlock"))

    @cidr_block.setter
    def cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__129ecbd2fa74c873db5d2e4445a6d4ee5848a7ae54ad620420c16424ba00add1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="egress")
    def egress(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Whether this rule applies to egress traffic from the subnet ( ``true`` ) or ingress traffic to the subnet ( ``false`` ).'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "egress"))

    @egress.setter
    def egress(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08c5f0306e44ef2382acc0166275e531bf85b83c5858166b4228bbff43cc19fc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "egress", value)

    @builtins.property
    @jsii.member(jsii_name="icmp")
    def icmp(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.IcmpProperty"]]:
        '''The Internet Control Message Protocol (ICMP) code and type.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.IcmpProperty"]], jsii.get(self, "icmp"))

    @icmp.setter
    def icmp(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.IcmpProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b053e8a1e1be8a080aa0335f9873632417b0a52584e06b761a7084959c966bc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "icmp", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6CidrBlock")
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 network range to allow or deny, in CIDR notation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6CidrBlock"))

    @ipv6_cidr_block.setter
    def ipv6_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__04e2aeb5634b173e21270f0907cd73e640f758e6e692039079590ffd3d306ba0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="portRange")
    def port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.PortRangeProperty"]]:
        '''The range of port numbers for the UDP/TCP protocol.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.PortRangeProperty"]], jsii.get(self, "portRange"))

    @port_range.setter
    def port_range(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkAclEntry.PortRangeProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d484cd32312fbba1da3eaef2ee23a41c2d099c402828e3b5a4713187568098d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "portRange", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAclEntry.IcmpProperty",
        jsii_struct_bases=[],
        name_mapping={"code": "code", "type": "type"},
    )
    class IcmpProperty:
        def __init__(
            self,
            *,
            code: typing.Optional[jsii.Number] = None,
            type: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes the ICMP type and code.

            :param code: The Internet Control Message Protocol (ICMP) code. You can use -1 to specify all ICMP codes for the given ICMP type. Required if you specify 1 (ICMP) for the protocol parameter.
            :param type: The Internet Control Message Protocol (ICMP) type. You can use -1 to specify all ICMP types. Conditional requirement: Required if you specify 1 (ICMP) for the ``CreateNetworkAclEntry`` protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-icmp.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                icmp_property = ec2.CfnNetworkAclEntry.IcmpProperty(
                    code=123,
                    type=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c0db35b941edee121dbe70aad21d789ad482729a830de6371c64bd02f1440dc0)
                check_type(argname="argument code", value=code, expected_type=type_hints["code"])
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if code is not None:
                self._values["code"] = code
            if type is not None:
                self._values["type"] = type

        @builtins.property
        def code(self) -> typing.Optional[jsii.Number]:
            '''The Internet Control Message Protocol (ICMP) code.

            You can use -1 to specify all ICMP codes for the given ICMP type. Required if you specify 1 (ICMP) for the protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-icmp.html#cfn-ec2-networkaclentry-icmp-code
            '''
            result = self._values.get("code")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def type(self) -> typing.Optional[jsii.Number]:
            '''The Internet Control Message Protocol (ICMP) type.

            You can use -1 to specify all ICMP types. Conditional requirement: Required if you specify 1 (ICMP) for the ``CreateNetworkAclEntry`` protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-icmp.html#cfn-ec2-networkaclentry-icmp-type
            '''
            result = self._values.get("type")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IcmpProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAclEntry.PortRangeProperty",
        jsii_struct_bases=[],
        name_mapping={"from_": "from", "to": "to"},
    )
    class PortRangeProperty:
        def __init__(
            self,
            *,
            from_: typing.Optional[jsii.Number] = None,
            to: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a range of ports.

            :param from_: The first port in the range. Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.
            :param to: The last port in the range. Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-portrange.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                port_range_property = ec2.CfnNetworkAclEntry.PortRangeProperty(
                    from=123,
                    to=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__afc777693f9aa0b09a2626bc7d7fe62ad0760ffb7468f177d913ba053b48cf13)
                check_type(argname="argument from_", value=from_, expected_type=type_hints["from_"])
                check_type(argname="argument to", value=to, expected_type=type_hints["to"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if from_ is not None:
                self._values["from_"] = from_
            if to is not None:
                self._values["to"] = to

        @builtins.property
        def from_(self) -> typing.Optional[jsii.Number]:
            '''The first port in the range.

            Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-portrange.html#cfn-ec2-networkaclentry-portrange-from
            '''
            result = self._values.get("from_")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def to(self) -> typing.Optional[jsii.Number]:
            '''The last port in the range.

            Required if you specify 6 (TCP) or 17 (UDP) for the protocol parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkaclentry-portrange.html#cfn-ec2-networkaclentry-portrange-to
            '''
            result = self._values.get("to")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PortRangeProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAclEntryProps",
    jsii_struct_bases=[],
    name_mapping={
        "network_acl_id": "networkAclId",
        "protocol": "protocol",
        "rule_action": "ruleAction",
        "rule_number": "ruleNumber",
        "cidr_block": "cidrBlock",
        "egress": "egress",
        "icmp": "icmp",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "port_range": "portRange",
    },
)
class CfnNetworkAclEntryProps:
    def __init__(
        self,
        *,
        network_acl_id: builtins.str,
        protocol: jsii.Number,
        rule_action: builtins.str,
        rule_number: jsii.Number,
        cidr_block: typing.Optional[builtins.str] = None,
        egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        icmp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.IcmpProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkAclEntry``.

        :param network_acl_id: The ID of the ACL for the entry.
        :param protocol: The IP protocol that the rule applies to. You must specify -1 or a protocol number. You can specify -1 for all protocols. .. epigraph:: If you specify -1, all ports are opened and the ``PortRange`` property is ignored.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny".
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param cidr_block: The IPv4 CIDR range to allow or deny, in CIDR notation (for example, 172.16.0.0/24). You must specify an IPv4 CIDR block or an IPv6 CIDR block.
        :param egress: Whether this rule applies to egress traffic from the subnet ( ``true`` ) or ingress traffic to the subnet ( ``false`` ). By default, AWS CloudFormation specifies ``false`` .
        :param icmp: The Internet Control Message Protocol (ICMP) code and type. Required if specifying 1 (ICMP) for the protocol parameter.
        :param ipv6_cidr_block: The IPv6 network range to allow or deny, in CIDR notation. You must specify an IPv4 CIDR block or an IPv6 CIDR block.
        :param port_range: The range of port numbers for the UDP/TCP protocol. Required if specifying 6 (TCP) or 17 (UDP) for the protocol parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_acl_entry_props = ec2.CfnNetworkAclEntryProps(
                network_acl_id="networkAclId",
                protocol=123,
                rule_action="ruleAction",
                rule_number=123,
            
                # the properties below are optional
                cidr_block="cidrBlock",
                egress=False,
                icmp=ec2.CfnNetworkAclEntry.IcmpProperty(
                    code=123,
                    type=123
                ),
                ipv6_cidr_block="ipv6CidrBlock",
                port_range=ec2.CfnNetworkAclEntry.PortRangeProperty(
                    from=123,
                    to=123
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3acf503d4b182329e1fcd58e01c111f3c896325c25e0cab3daa1d1107293e25f)
            check_type(argname="argument network_acl_id", value=network_acl_id, expected_type=type_hints["network_acl_id"])
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument rule_action", value=rule_action, expected_type=type_hints["rule_action"])
            check_type(argname="argument rule_number", value=rule_number, expected_type=type_hints["rule_number"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument egress", value=egress, expected_type=type_hints["egress"])
            check_type(argname="argument icmp", value=icmp, expected_type=type_hints["icmp"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_acl_id": network_acl_id,
            "protocol": protocol,
            "rule_action": rule_action,
            "rule_number": rule_number,
        }
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if egress is not None:
            self._values["egress"] = egress
        if icmp is not None:
            self._values["icmp"] = icmp
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if port_range is not None:
            self._values["port_range"] = port_range

    @builtins.property
    def network_acl_id(self) -> builtins.str:
        '''The ID of the ACL for the entry.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-networkaclid
        '''
        result = self._values.get("network_acl_id")
        assert result is not None, "Required property 'network_acl_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def protocol(self) -> jsii.Number:
        '''The IP protocol that the rule applies to.

        You must specify -1 or a protocol number. You can specify -1 for all protocols.
        .. epigraph::

           If you specify -1, all ports are opened and the ``PortRange`` property is ignored.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-protocol
        '''
        result = self._values.get("protocol")
        assert result is not None, "Required property 'protocol' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def rule_action(self) -> builtins.str:
        '''Whether to allow or deny traffic that matches the rule;

        valid values are "allow" or "deny".

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-ruleaction
        '''
        result = self._values.get("rule_action")
        assert result is not None, "Required property 'rule_action' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rule_number(self) -> jsii.Number:
        '''Rule number to assign to the entry, such as 100.

        ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-rulenumber
        '''
        result = self._values.get("rule_number")
        assert result is not None, "Required property 'rule_number' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR range to allow or deny, in CIDR notation (for example, 172.16.0.0/24). You must specify an IPv4 CIDR block or an IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-cidrblock
        '''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def egress(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Whether this rule applies to egress traffic from the subnet ( ``true`` ) or ingress traffic to the subnet ( ``false`` ).

        By default, AWS CloudFormation specifies ``false`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-egress
        '''
        result = self._values.get("egress")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def icmp(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.IcmpProperty]]:
        '''The Internet Control Message Protocol (ICMP) code and type.

        Required if specifying 1 (ICMP) for the protocol parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-icmp
        '''
        result = self._values.get("icmp")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.IcmpProperty]], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 network range to allow or deny, in CIDR notation.

        You must specify an IPv4 CIDR block or an IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-ipv6cidrblock
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.PortRangeProperty]]:
        '''The range of port numbers for the UDP/TCP protocol.

        Required if specifying 6 (TCP) or 17 (UDP) for the protocol parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkaclentry.html#cfn-ec2-networkaclentry-portrange
        '''
        result = self._values.get("port_range")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.PortRangeProperty]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkAclEntryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkAclProps",
    jsii_struct_bases=[],
    name_mapping={"vpc_id": "vpcId", "tags": "tags"},
)
class CfnNetworkAclProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkAcl``.

        :param vpc_id: The ID of the VPC for the network ACL.
        :param tags: The tags for the network ACL.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkacl.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_acl_props = ec2.CfnNetworkAclProps(
                vpc_id="vpcId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__15f21d92eb458fa0909676d3a26ee9828dde8826809c48354215e1a66776d40f)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC for the network ACL.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkacl.html#cfn-ec2-networkacl-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the network ACL.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkacl.html#cfn-ec2-networkacl-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkAclProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkInsightsAccessScope(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope",
):
    '''Describes a Network Access Scope.

    A Network Access Scope defines outbound (egress) and inbound (ingress) traffic patterns, including sources, destinations, paths, and traffic types.

    Network Access Analyzer identifies unintended network access to your resources on AWS . When you start an analysis on a Network Access Scope, Network Access Analyzer produces findings. For more information, see the `Network Access Analyzer User Guide <https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscope.html
    :cloudformationResource: AWS::EC2::NetworkInsightsAccessScope
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_insights_access_scope = ec2.CfnNetworkInsightsAccessScope(self, "MyCfnNetworkInsightsAccessScope",
            exclude_paths=[ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty(
                destination=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                    packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_ports=["destinationPorts"],
                        destination_prefix_lists=["destinationPrefixLists"],
                        protocols=["protocols"],
                        source_addresses=["sourceAddresses"],
                        source_ports=["sourcePorts"],
                        source_prefix_lists=["sourcePrefixLists"]
                    ),
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                ),
                source=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                    packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_ports=["destinationPorts"],
                        destination_prefix_lists=["destinationPrefixLists"],
                        protocols=["protocols"],
                        source_addresses=["sourceAddresses"],
                        source_ports=["sourcePorts"],
                        source_prefix_lists=["sourcePrefixLists"]
                    ),
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                ),
                through_resources=[ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                )]
            )],
            match_paths=[ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty(
                destination=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                    packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_ports=["destinationPorts"],
                        destination_prefix_lists=["destinationPrefixLists"],
                        protocols=["protocols"],
                        source_addresses=["sourceAddresses"],
                        source_ports=["sourcePorts"],
                        source_prefix_lists=["sourcePrefixLists"]
                    ),
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                ),
                source=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                    packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_ports=["destinationPorts"],
                        destination_prefix_lists=["destinationPrefixLists"],
                        protocols=["protocols"],
                        source_addresses=["sourceAddresses"],
                        source_ports=["sourcePorts"],
                        source_prefix_lists=["sourcePrefixLists"]
                    ),
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                ),
                through_resources=[ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                )]
            )],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        exclude_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        match_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param exclude_paths: The paths to exclude.
        :param match_paths: The paths to match.
        :param tags: The tags.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__09b42a4fb4e9f46bed23ddfbf1c07b2a0ba5e4fce3bed5ffdc5d40d39c2f8ffd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInsightsAccessScopeProps(
            exclude_paths=exclude_paths, match_paths=match_paths, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f82b6edd1eb1b26cfbde99da725d72fca487a4954f8210236670099b07e4389)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b30482d779ea4915ee6674a7a8f8c7418883ca6e720b6b11926119a171f06434)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreatedDate")
    def attr_created_date(self) -> builtins.str:
        '''The creation date.

        :cloudformationAttribute: CreatedDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreatedDate"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAccessScopeArn")
    def attr_network_insights_access_scope_arn(self) -> builtins.str:
        '''The ARN of the Network Access Scope.

        :cloudformationAttribute: NetworkInsightsAccessScopeArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAccessScopeArn"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAccessScopeId")
    def attr_network_insights_access_scope_id(self) -> builtins.str:
        '''The ID of the Network Access Scope.

        :cloudformationAttribute: NetworkInsightsAccessScopeId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAccessScopeId"))

    @builtins.property
    @jsii.member(jsii_name="attrUpdatedDate")
    def attr_updated_date(self) -> builtins.str:
        '''The last updated date.

        :cloudformationAttribute: UpdatedDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrUpdatedDate"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="excludePaths")
    def exclude_paths(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]]:
        '''The paths to exclude.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]], jsii.get(self, "excludePaths"))

    @exclude_paths.setter
    def exclude_paths(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bb0347180a5ec3db3a346f37de5fab9530bfa7f80f40f6b23c6d2bdf0525f22)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "excludePaths", value)

    @builtins.property
    @jsii.member(jsii_name="matchPaths")
    def match_paths(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]]:
        '''The paths to match.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]], jsii.get(self, "matchPaths"))

    @match_paths.setter
    def match_paths(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__65876aff79dd4703d35911a15193603293801dc94a026bc18667715be0714b74)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "matchPaths", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a0d4ed7f5b5d6568c9fb7c0d99b3085a29b3ecf85d1e42a3766dca2e9e60034)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "destination": "destination",
            "source": "source",
            "through_resources": "throughResources",
        },
    )
    class AccessScopePathRequestProperty:
        def __init__(
            self,
            *,
            destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.PathStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.PathStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            through_resources: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ) -> None:
            '''Describes a path.

            :param destination: The destination.
            :param source: The source.
            :param through_resources: The through resources.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-accessscopepathrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                access_scope_path_request_property = ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty(
                    destination=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    source=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    through_resources=[ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6479b3ab49757210a848311fe5bc0762e4e69165883629ed0f5af1f54e1c437e)
                check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
                check_type(argname="argument source", value=source, expected_type=type_hints["source"])
                check_type(argname="argument through_resources", value=through_resources, expected_type=type_hints["through_resources"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if destination is not None:
                self._values["destination"] = destination
            if source is not None:
                self._values["source"] = source
            if through_resources is not None:
                self._values["through_resources"] = through_resources

        @builtins.property
        def destination(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PathStatementRequestProperty"]]:
            '''The destination.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-accessscopepathrequest.html#cfn-ec2-networkinsightsaccessscope-accessscopepathrequest-destination
            '''
            result = self._values.get("destination")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PathStatementRequestProperty"]], result)

        @builtins.property
        def source(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PathStatementRequestProperty"]]:
            '''The source.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-accessscopepathrequest.html#cfn-ec2-networkinsightsaccessscope-accessscopepathrequest-source
            '''
            result = self._values.get("source")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PathStatementRequestProperty"]], result)

        @builtins.property
        def through_resources(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty"]]]]:
            '''The through resources.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-accessscopepathrequest.html#cfn-ec2-networkinsightsaccessscope-accessscopepathrequest-throughresources
            '''
            result = self._values.get("through_resources")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty"]]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AccessScopePathRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "destination_addresses": "destinationAddresses",
            "destination_ports": "destinationPorts",
            "destination_prefix_lists": "destinationPrefixLists",
            "protocols": "protocols",
            "source_addresses": "sourceAddresses",
            "source_ports": "sourcePorts",
            "source_prefix_lists": "sourcePrefixLists",
        },
    )
    class PacketHeaderStatementRequestProperty:
        def __init__(
            self,
            *,
            destination_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
            destination_ports: typing.Optional[typing.Sequence[builtins.str]] = None,
            destination_prefix_lists: typing.Optional[typing.Sequence[builtins.str]] = None,
            protocols: typing.Optional[typing.Sequence[builtins.str]] = None,
            source_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
            source_ports: typing.Optional[typing.Sequence[builtins.str]] = None,
            source_prefix_lists: typing.Optional[typing.Sequence[builtins.str]] = None,
        ) -> None:
            '''Describes a packet header statement.

            :param destination_addresses: The destination addresses.
            :param destination_ports: The destination ports.
            :param destination_prefix_lists: The destination prefix lists.
            :param protocols: The protocols.
            :param source_addresses: The source addresses.
            :param source_ports: The source ports.
            :param source_prefix_lists: The source prefix lists.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                packet_header_statement_request_property = ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                    destination_addresses=["destinationAddresses"],
                    destination_ports=["destinationPorts"],
                    destination_prefix_lists=["destinationPrefixLists"],
                    protocols=["protocols"],
                    source_addresses=["sourceAddresses"],
                    source_ports=["sourcePorts"],
                    source_prefix_lists=["sourcePrefixLists"]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__3ee0103585d5d78120d38ea844a62f80bdab984d8dd6f86aa16b343aedc1c6fc)
                check_type(argname="argument destination_addresses", value=destination_addresses, expected_type=type_hints["destination_addresses"])
                check_type(argname="argument destination_ports", value=destination_ports, expected_type=type_hints["destination_ports"])
                check_type(argname="argument destination_prefix_lists", value=destination_prefix_lists, expected_type=type_hints["destination_prefix_lists"])
                check_type(argname="argument protocols", value=protocols, expected_type=type_hints["protocols"])
                check_type(argname="argument source_addresses", value=source_addresses, expected_type=type_hints["source_addresses"])
                check_type(argname="argument source_ports", value=source_ports, expected_type=type_hints["source_ports"])
                check_type(argname="argument source_prefix_lists", value=source_prefix_lists, expected_type=type_hints["source_prefix_lists"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if destination_addresses is not None:
                self._values["destination_addresses"] = destination_addresses
            if destination_ports is not None:
                self._values["destination_ports"] = destination_ports
            if destination_prefix_lists is not None:
                self._values["destination_prefix_lists"] = destination_prefix_lists
            if protocols is not None:
                self._values["protocols"] = protocols
            if source_addresses is not None:
                self._values["source_addresses"] = source_addresses
            if source_ports is not None:
                self._values["source_ports"] = source_ports
            if source_prefix_lists is not None:
                self._values["source_prefix_lists"] = source_prefix_lists

        @builtins.property
        def destination_addresses(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The destination addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-destinationaddresses
            '''
            result = self._values.get("destination_addresses")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def destination_ports(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The destination ports.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-destinationports
            '''
            result = self._values.get("destination_ports")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def destination_prefix_lists(
            self,
        ) -> typing.Optional[typing.List[builtins.str]]:
            '''The destination prefix lists.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-destinationprefixlists
            '''
            result = self._values.get("destination_prefix_lists")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def protocols(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The protocols.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-protocols
            '''
            result = self._values.get("protocols")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def source_addresses(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The source addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-sourceaddresses
            '''
            result = self._values.get("source_addresses")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def source_ports(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The source ports.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-sourceports
            '''
            result = self._values.get("source_ports")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def source_prefix_lists(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The source prefix lists.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-packetheaderstatementrequest.html#cfn-ec2-networkinsightsaccessscope-packetheaderstatementrequest-sourceprefixlists
            '''
            result = self._values.get("source_prefix_lists")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PacketHeaderStatementRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "packet_header_statement": "packetHeaderStatement",
            "resource_statement": "resourceStatement",
        },
    )
    class PathStatementRequestProperty:
        def __init__(
            self,
            *,
            packet_header_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            resource_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes a path statement.

            :param packet_header_statement: The packet header statement.
            :param resource_statement: The resource statement.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-pathstatementrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                path_statement_request_property = ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                    packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_ports=["destinationPorts"],
                        destination_prefix_lists=["destinationPrefixLists"],
                        protocols=["protocols"],
                        source_addresses=["sourceAddresses"],
                        source_ports=["sourcePorts"],
                        source_prefix_lists=["sourcePrefixLists"]
                    ),
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__93939c954b7527e924a6bb467ac28976dae5a92c7d9d73a22cc548e3af25e1d6)
                check_type(argname="argument packet_header_statement", value=packet_header_statement, expected_type=type_hints["packet_header_statement"])
                check_type(argname="argument resource_statement", value=resource_statement, expected_type=type_hints["resource_statement"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if packet_header_statement is not None:
                self._values["packet_header_statement"] = packet_header_statement
            if resource_statement is not None:
                self._values["resource_statement"] = resource_statement

        @builtins.property
        def packet_header_statement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty"]]:
            '''The packet header statement.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-pathstatementrequest.html#cfn-ec2-networkinsightsaccessscope-pathstatementrequest-packetheaderstatement
            '''
            result = self._values.get("packet_header_statement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty"]], result)

        @builtins.property
        def resource_statement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty"]]:
            '''The resource statement.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-pathstatementrequest.html#cfn-ec2-networkinsightsaccessscope-pathstatementrequest-resourcestatement
            '''
            result = self._values.get("resource_statement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PathStatementRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"resources": "resources", "resource_types": "resourceTypes"},
    )
    class ResourceStatementRequestProperty:
        def __init__(
            self,
            *,
            resources: typing.Optional[typing.Sequence[builtins.str]] = None,
            resource_types: typing.Optional[typing.Sequence[builtins.str]] = None,
        ) -> None:
            '''Describes a resource statement.

            :param resources: The resources.
            :param resource_types: The resource types.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-resourcestatementrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                resource_statement_request_property = ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                    resources=["resources"],
                    resource_types=["resourceTypes"]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8d8211512ba3ac4899e7d8c3bf7b860e597fb5de548139d64df2067625abcaec)
                check_type(argname="argument resources", value=resources, expected_type=type_hints["resources"])
                check_type(argname="argument resource_types", value=resource_types, expected_type=type_hints["resource_types"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resources is not None:
                self._values["resources"] = resources
            if resource_types is not None:
                self._values["resource_types"] = resource_types

        @builtins.property
        def resources(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The resources.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-resourcestatementrequest.html#cfn-ec2-networkinsightsaccessscope-resourcestatementrequest-resources
            '''
            result = self._values.get("resources")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def resource_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The resource types.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-resourcestatementrequest.html#cfn-ec2-networkinsightsaccessscope-resourcestatementrequest-resourcetypes
            '''
            result = self._values.get("resource_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ResourceStatementRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_statement": "resourceStatement"},
    )
    class ThroughResourcesStatementRequestProperty:
        def __init__(
            self,
            *,
            resource_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes a through resource statement.

            :param resource_statement: The resource statement.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-throughresourcesstatementrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                through_resources_statement_request_property = ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                    resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                        resources=["resources"],
                        resource_types=["resourceTypes"]
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__25edd4e745cb3b2bfba6b70745820805974b1ae2ef9d490e7b232b0b8a720b6b)
                check_type(argname="argument resource_statement", value=resource_statement, expected_type=type_hints["resource_statement"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_statement is not None:
                self._values["resource_statement"] = resource_statement

        @builtins.property
        def resource_statement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty"]]:
            '''The resource statement.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsaccessscope-throughresourcesstatementrequest.html#cfn-ec2-networkinsightsaccessscope-throughresourcesstatementrequest-resourcestatement
            '''
            result = self._values.get("resource_statement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ThroughResourcesStatementRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkInsightsAccessScopeAnalysis(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScopeAnalysis",
):
    '''Describes a Network Access Scope analysis.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscopeanalysis.html
    :cloudformationResource: AWS::EC2::NetworkInsightsAccessScopeAnalysis
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_insights_access_scope_analysis = ec2.CfnNetworkInsightsAccessScopeAnalysis(self, "MyCfnNetworkInsightsAccessScopeAnalysis",
            network_insights_access_scope_id="networkInsightsAccessScopeId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_insights_access_scope_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param network_insights_access_scope_id: The ID of the Network Access Scope.
        :param tags: The tags.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a18949cfdbc5dfd56eecde43f3705bb58594f84d85b5e275c607e6230ac9be1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInsightsAccessScopeAnalysisProps(
            network_insights_access_scope_id=network_insights_access_scope_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__68cf59f8d4cf1c47ec6143ca5ae0d86c2d23eda017b95478e02794d1802115fb)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__be469dd814ca765ec96bb5f8ddc18f7a35d96d393de5ca5220551968e50e4a46)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAnalyzedEniCount")
    def attr_analyzed_eni_count(self) -> jsii.Number:
        '''The number of network interfaces analyzed.

        :cloudformationAttribute: AnalyzedEniCount
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrAnalyzedEniCount"))

    @builtins.property
    @jsii.member(jsii_name="attrEndDate")
    def attr_end_date(self) -> builtins.str:
        '''The end date of the analysis.

        :cloudformationAttribute: EndDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrEndDate"))

    @builtins.property
    @jsii.member(jsii_name="attrFindingsFound")
    def attr_findings_found(self) -> builtins.str:
        '''Indicates whether there are findings (true | false | unknown).

        :cloudformationAttribute: FindingsFound
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrFindingsFound"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAccessScopeAnalysisArn")
    def attr_network_insights_access_scope_analysis_arn(self) -> builtins.str:
        '''The ARN of the Network Access Scope analysis.

        :cloudformationAttribute: NetworkInsightsAccessScopeAnalysisArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAccessScopeAnalysisArn"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAccessScopeAnalysisId")
    def attr_network_insights_access_scope_analysis_id(self) -> builtins.str:
        '''The ID of the Network Access Scope analysis.

        :cloudformationAttribute: NetworkInsightsAccessScopeAnalysisId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAccessScopeAnalysisId"))

    @builtins.property
    @jsii.member(jsii_name="attrStartDate")
    def attr_start_date(self) -> builtins.str:
        '''The start date of the analysis.

        :cloudformationAttribute: StartDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStartDate"))

    @builtins.property
    @jsii.member(jsii_name="attrStatus")
    def attr_status(self) -> builtins.str:
        '''The status of the analysis (running | succeeded | failed).

        :cloudformationAttribute: Status
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatus"))

    @builtins.property
    @jsii.member(jsii_name="attrStatusMessage")
    def attr_status_message(self) -> builtins.str:
        '''The status message.

        :cloudformationAttribute: StatusMessage
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatusMessage"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="networkInsightsAccessScopeId")
    def network_insights_access_scope_id(self) -> builtins.str:
        '''The ID of the Network Access Scope.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInsightsAccessScopeId"))

    @network_insights_access_scope_id.setter
    def network_insights_access_scope_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2e6193e07361f6833215e82224bd3bd89dd2f89ac49cfcf28b160f2b6bf214e5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInsightsAccessScopeId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b40caa93e4cba14aa0ed92e1157e230d9574ded15319d47645dac942e2a4904)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScopeAnalysisProps",
    jsii_struct_bases=[],
    name_mapping={
        "network_insights_access_scope_id": "networkInsightsAccessScopeId",
        "tags": "tags",
    },
)
class CfnNetworkInsightsAccessScopeAnalysisProps:
    def __init__(
        self,
        *,
        network_insights_access_scope_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInsightsAccessScopeAnalysis``.

        :param network_insights_access_scope_id: The ID of the Network Access Scope.
        :param tags: The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscopeanalysis.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_insights_access_scope_analysis_props = ec2.CfnNetworkInsightsAccessScopeAnalysisProps(
                network_insights_access_scope_id="networkInsightsAccessScopeId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6456971e54f3d6847be0673f8e983c36e0c8fa5cac3cab9cd3eebc9d3fe829ad)
            check_type(argname="argument network_insights_access_scope_id", value=network_insights_access_scope_id, expected_type=type_hints["network_insights_access_scope_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_insights_access_scope_id": network_insights_access_scope_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def network_insights_access_scope_id(self) -> builtins.str:
        '''The ID of the Network Access Scope.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscopeanalysis.html#cfn-ec2-networkinsightsaccessscopeanalysis-networkinsightsaccessscopeid
        '''
        result = self._values.get("network_insights_access_scope_id")
        assert result is not None, "Required property 'network_insights_access_scope_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscopeanalysis.html#cfn-ec2-networkinsightsaccessscopeanalysis-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInsightsAccessScopeAnalysisProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAccessScopeProps",
    jsii_struct_bases=[],
    name_mapping={
        "exclude_paths": "excludePaths",
        "match_paths": "matchPaths",
        "tags": "tags",
    },
)
class CfnNetworkInsightsAccessScopeProps:
    def __init__(
        self,
        *,
        exclude_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        match_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInsightsAccessScope``.

        :param exclude_paths: The paths to exclude.
        :param match_paths: The paths to match.
        :param tags: The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscope.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_insights_access_scope_props = ec2.CfnNetworkInsightsAccessScopeProps(
                exclude_paths=[ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty(
                    destination=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    source=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    through_resources=[ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    )]
                )],
                match_paths=[ec2.CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty(
                    destination=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    source=ec2.CfnNetworkInsightsAccessScope.PathStatementRequestProperty(
                        packet_header_statement=ec2.CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty(
                            destination_addresses=["destinationAddresses"],
                            destination_ports=["destinationPorts"],
                            destination_prefix_lists=["destinationPrefixLists"],
                            protocols=["protocols"],
                            source_addresses=["sourceAddresses"],
                            source_ports=["sourcePorts"],
                            source_prefix_lists=["sourcePrefixLists"]
                        ),
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    ),
                    through_resources=[ec2.CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty(
                        resource_statement=ec2.CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty(
                            resources=["resources"],
                            resource_types=["resourceTypes"]
                        )
                    )]
                )],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__97bfb3f2e7cd49d7181b48521f8fb397e6d46ad8504bb9c725209cb75789f6db)
            check_type(argname="argument exclude_paths", value=exclude_paths, expected_type=type_hints["exclude_paths"])
            check_type(argname="argument match_paths", value=match_paths, expected_type=type_hints["match_paths"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if exclude_paths is not None:
            self._values["exclude_paths"] = exclude_paths
        if match_paths is not None:
            self._values["match_paths"] = match_paths
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def exclude_paths(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]]:
        '''The paths to exclude.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscope.html#cfn-ec2-networkinsightsaccessscope-excludepaths
        '''
        result = self._values.get("exclude_paths")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]], result)

    @builtins.property
    def match_paths(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]]:
        '''The paths to match.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscope.html#cfn-ec2-networkinsightsaccessscope-matchpaths
        '''
        result = self._values.get("match_paths")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsaccessscope.html#cfn-ec2-networkinsightsaccessscope-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInsightsAccessScopeProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkInsightsAnalysis(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis",
):
    '''Specifies a network insights analysis.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html
    :cloudformationResource: AWS::EC2::NetworkInsightsAnalysis
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_insights_analysis = ec2.CfnNetworkInsightsAnalysis(self, "MyCfnNetworkInsightsAnalysis",
            network_insights_path_id="networkInsightsPathId",
        
            # the properties below are optional
            additional_accounts=["additionalAccounts"],
            filter_in_arns=["filterInArns"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_insights_path_id: builtins.str,
        additional_accounts: typing.Optional[typing.Sequence[builtins.str]] = None,
        filter_in_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param network_insights_path_id: The ID of the path.
        :param additional_accounts: The member accounts that contain resources that the path can traverse.
        :param filter_in_arns: The Amazon Resource Names (ARN) of the resources that the path must traverse.
        :param tags: The tags to apply.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__678aad296e8f8e492a0d5ebb106e185ee0e54a22ad01e148f0ae03d0090508d2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInsightsAnalysisProps(
            network_insights_path_id=network_insights_path_id,
            additional_accounts=additional_accounts,
            filter_in_arns=filter_in_arns,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__511339e103b3d28b7af09ce19b36ce54bde77d57587d4e29f2c94e9283956101)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c131de58a1c5605791fee50271e3a5ca23af6236ecce8ebe988aca3273e8817)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAlternatePathHints")
    def attr_alternate_path_hints(self) -> _IResolvable_da3f097b:
        '''Potential intermediate components.

        :cloudformationAttribute: AlternatePathHints
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrAlternatePathHints"))

    @builtins.property
    @jsii.member(jsii_name="attrExplanations")
    def attr_explanations(self) -> _IResolvable_da3f097b:
        '''The explanations.

        For more information, see `Reachability Analyzer explanation codes <https://docs.aws.amazon.com/vpc/latest/reachability/explanation-codes.html>`_ .

        :cloudformationAttribute: Explanations
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrExplanations"))

    @builtins.property
    @jsii.member(jsii_name="attrForwardPathComponents")
    def attr_forward_path_components(self) -> _IResolvable_da3f097b:
        '''The components in the path from source to destination.

        :cloudformationAttribute: ForwardPathComponents
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrForwardPathComponents"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAnalysisArn")
    def attr_network_insights_analysis_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the network insights analysis.

        :cloudformationAttribute: NetworkInsightsAnalysisArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAnalysisArn"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsAnalysisId")
    def attr_network_insights_analysis_id(self) -> builtins.str:
        '''The ID of the network insights analysis.

        :cloudformationAttribute: NetworkInsightsAnalysisId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsAnalysisId"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkPathFound")
    def attr_network_path_found(self) -> _IResolvable_da3f097b:
        '''Indicates whether the destination is reachable from the source.

        :cloudformationAttribute: NetworkPathFound
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrNetworkPathFound"))

    @builtins.property
    @jsii.member(jsii_name="attrReturnPathComponents")
    def attr_return_path_components(self) -> _IResolvable_da3f097b:
        '''The components in the path from destination to source.

        :cloudformationAttribute: ReturnPathComponents
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrReturnPathComponents"))

    @builtins.property
    @jsii.member(jsii_name="attrStartDate")
    def attr_start_date(self) -> builtins.str:
        '''The time the analysis started.

        :cloudformationAttribute: StartDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStartDate"))

    @builtins.property
    @jsii.member(jsii_name="attrStatus")
    def attr_status(self) -> builtins.str:
        '''The status of the network insights analysis.

        :cloudformationAttribute: Status
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatus"))

    @builtins.property
    @jsii.member(jsii_name="attrStatusMessage")
    def attr_status_message(self) -> builtins.str:
        '''The status message, if the status is ``failed`` .

        :cloudformationAttribute: StatusMessage
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatusMessage"))

    @builtins.property
    @jsii.member(jsii_name="attrSuggestedAccounts")
    def attr_suggested_accounts(self) -> typing.List[builtins.str]:
        '''The IDs of potential intermediate accounts.

        :cloudformationAttribute: SuggestedAccounts
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrSuggestedAccounts"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="networkInsightsPathId")
    def network_insights_path_id(self) -> builtins.str:
        '''The ID of the path.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInsightsPathId"))

    @network_insights_path_id.setter
    def network_insights_path_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83f5f2cf16339baf897c63be3cf60b3efd0d6b4e660e79516e522a217a0832c9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInsightsPathId", value)

    @builtins.property
    @jsii.member(jsii_name="additionalAccounts")
    def additional_accounts(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The member accounts that contain resources that the path can traverse.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "additionalAccounts"))

    @additional_accounts.setter
    def additional_accounts(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2df3bab5870c8ebb5ce0c70ae7fffe3391dc7b093a2f7778407d2d629f1343f8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "additionalAccounts", value)

    @builtins.property
    @jsii.member(jsii_name="filterInArns")
    def filter_in_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARN) of the resources that the path must traverse.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "filterInArns"))

    @filter_in_arns.setter
    def filter_in_arns(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5fc330fa3d4b736d5224dcb5d8f30fe938109a4316d70b31bac388cd1a1249ca)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "filterInArns", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9412010e2d8bad87553154226eb22ca797b6afeb1de0474359133f2783db6f65)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AdditionalDetailProperty",
        jsii_struct_bases=[],
        name_mapping={
            "additional_detail_type": "additionalDetailType",
            "component": "component",
            "load_balancers": "loadBalancers",
            "service_name": "serviceName",
        },
    )
    class AdditionalDetailProperty:
        def __init__(
            self,
            *,
            additional_detail_type: typing.Optional[builtins.str] = None,
            component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            service_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes an additional detail for a path analysis.

            For more information, see `Reachability Analyzer additional detail codes <https://docs.aws.amazon.com/vpc/latest/reachability/additional-detail-codes.html>`_ .

            :param additional_detail_type: The additional detail code.
            :param component: The path component.
            :param load_balancers: The load balancers.
            :param service_name: The name of the VPC endpoint service.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-additionaldetail.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                additional_detail_property = ec2.CfnNetworkInsightsAnalysis.AdditionalDetailProperty(
                    additional_detail_type="additionalDetailType",
                    component=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    load_balancers=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    )],
                    service_name="serviceName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__3fedc66c800cdce70eae824210869d84cd51332bedb7734ee970f48424dbb743)
                check_type(argname="argument additional_detail_type", value=additional_detail_type, expected_type=type_hints["additional_detail_type"])
                check_type(argname="argument component", value=component, expected_type=type_hints["component"])
                check_type(argname="argument load_balancers", value=load_balancers, expected_type=type_hints["load_balancers"])
                check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if additional_detail_type is not None:
                self._values["additional_detail_type"] = additional_detail_type
            if component is not None:
                self._values["component"] = component
            if load_balancers is not None:
                self._values["load_balancers"] = load_balancers
            if service_name is not None:
                self._values["service_name"] = service_name

        @builtins.property
        def additional_detail_type(self) -> typing.Optional[builtins.str]:
            '''The additional detail code.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-additionaldetail.html#cfn-ec2-networkinsightsanalysis-additionaldetail-additionaldetailtype
            '''
            result = self._values.get("additional_detail_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def component(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The path component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-additionaldetail.html#cfn-ec2-networkinsightsanalysis-additionaldetail-component
            '''
            result = self._values.get("component")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def load_balancers(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]]:
            '''The load balancers.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-additionaldetail.html#cfn-ec2-networkinsightsanalysis-additionaldetail-loadbalancers
            '''
            result = self._values.get("load_balancers")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]], result)

        @builtins.property
        def service_name(self) -> typing.Optional[builtins.str]:
            '''The name of the VPC endpoint service.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-additionaldetail.html#cfn-ec2-networkinsightsanalysis-additionaldetail-servicename
            '''
            result = self._values.get("service_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AdditionalDetailProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AlternatePathHintProperty",
        jsii_struct_bases=[],
        name_mapping={"component_arn": "componentArn", "component_id": "componentId"},
    )
    class AlternatePathHintProperty:
        def __init__(
            self,
            *,
            component_arn: typing.Optional[builtins.str] = None,
            component_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes an potential intermediate component of a feasible path.

            :param component_arn: The Amazon Resource Name (ARN) of the component.
            :param component_id: The ID of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-alternatepathhint.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                alternate_path_hint_property = ec2.CfnNetworkInsightsAnalysis.AlternatePathHintProperty(
                    component_arn="componentArn",
                    component_id="componentId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__beadac39f70cfb599aae93e9b749826b009e53c821ac630de967601f6c75d771)
                check_type(argname="argument component_arn", value=component_arn, expected_type=type_hints["component_arn"])
                check_type(argname="argument component_id", value=component_id, expected_type=type_hints["component_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if component_arn is not None:
                self._values["component_arn"] = component_arn
            if component_id is not None:
                self._values["component_id"] = component_id

        @builtins.property
        def component_arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-alternatepathhint.html#cfn-ec2-networkinsightsanalysis-alternatepathhint-componentarn
            '''
            result = self._values.get("component_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def component_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-alternatepathhint.html#cfn-ec2-networkinsightsanalysis-alternatepathhint-componentid
            '''
            result = self._values.get("component_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AlternatePathHintProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty",
        jsii_struct_bases=[],
        name_mapping={
            "cidr": "cidr",
            "egress": "egress",
            "port_range": "portRange",
            "protocol": "protocol",
            "rule_action": "ruleAction",
            "rule_number": "ruleNumber",
        },
    )
    class AnalysisAclRuleProperty:
        def __init__(
            self,
            *,
            cidr: typing.Optional[builtins.str] = None,
            egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            protocol: typing.Optional[builtins.str] = None,
            rule_action: typing.Optional[builtins.str] = None,
            rule_number: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a network access control (ACL) rule.

            :param cidr: The IPv4 address range, in CIDR notation.
            :param egress: Indicates whether the rule is an outbound rule.
            :param port_range: The range of ports.
            :param protocol: The protocol.
            :param rule_action: Indicates whether to allow or deny traffic that matches the rule.
            :param rule_number: The rule number.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_acl_rule_property = ec2.CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty(
                    cidr="cidr",
                    egress=False,
                    port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                        from=123,
                        to=123
                    ),
                    protocol="protocol",
                    rule_action="ruleAction",
                    rule_number=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8aa10b86404f3998dbe1360ff1debd11265210eb283e280175517a104dc74916)
                check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
                check_type(argname="argument egress", value=egress, expected_type=type_hints["egress"])
                check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
                check_type(argname="argument rule_action", value=rule_action, expected_type=type_hints["rule_action"])
                check_type(argname="argument rule_number", value=rule_number, expected_type=type_hints["rule_number"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if cidr is not None:
                self._values["cidr"] = cidr
            if egress is not None:
                self._values["egress"] = egress
            if port_range is not None:
                self._values["port_range"] = port_range
            if protocol is not None:
                self._values["protocol"] = protocol
            if rule_action is not None:
                self._values["rule_action"] = rule_action
            if rule_number is not None:
                self._values["rule_number"] = rule_number

        @builtins.property
        def cidr(self) -> typing.Optional[builtins.str]:
            '''The IPv4 address range, in CIDR notation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-cidr
            '''
            result = self._values.get("cidr")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def egress(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the rule is an outbound rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-egress
            '''
            result = self._values.get("egress")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def port_range(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]:
            '''The range of ports.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-portrange
            '''
            result = self._values.get("port_range")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]], result)

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def rule_action(self) -> typing.Optional[builtins.str]:
            '''Indicates whether to allow or deny traffic that matches the rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-ruleaction
            '''
            result = self._values.get("rule_action")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def rule_number(self) -> typing.Optional[jsii.Number]:
            '''The rule number.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisaclrule.html#cfn-ec2-networkinsightsanalysis-analysisaclrule-rulenumber
            '''
            result = self._values.get("rule_number")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisAclRuleProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty",
        jsii_struct_bases=[],
        name_mapping={"arn": "arn", "id": "id"},
    )
    class AnalysisComponentProperty:
        def __init__(
            self,
            *,
            arn: typing.Optional[builtins.str] = None,
            id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a path component.

            :param arn: The Amazon Resource Name (ARN) of the component.
            :param id: The ID of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysiscomponent.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_component_property = ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                    arn="arn",
                    id="id"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c4ac71e6be6b0897ab2eb9eb5eca0038909daf307ba2e83852fdd87c048dde08)
                check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
                check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if arn is not None:
                self._values["arn"] = arn
            if id is not None:
                self._values["id"] = id

        @builtins.property
        def arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysiscomponent.html#cfn-ec2-networkinsightsanalysis-analysiscomponent-arn
            '''
            result = self._values.get("arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def id(self) -> typing.Optional[builtins.str]:
            '''The ID of the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysiscomponent.html#cfn-ec2-networkinsightsanalysis-analysiscomponent-id
            '''
            result = self._values.get("id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisComponentProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty",
        jsii_struct_bases=[],
        name_mapping={
            "instance_port": "instancePort",
            "load_balancer_port": "loadBalancerPort",
        },
    )
    class AnalysisLoadBalancerListenerProperty:
        def __init__(
            self,
            *,
            instance_port: typing.Optional[jsii.Number] = None,
            load_balancer_port: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a load balancer listener.

            :param instance_port: [Classic Load Balancers] The back-end port for the listener.
            :param load_balancer_port: The port on which the load balancer is listening.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancerlistener.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_load_balancer_listener_property = ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty(
                    instance_port=123,
                    load_balancer_port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__55653e2ecd12adb9d8fbe5221699b12bb7a99170d02ae297f5101be79a71c33f)
                check_type(argname="argument instance_port", value=instance_port, expected_type=type_hints["instance_port"])
                check_type(argname="argument load_balancer_port", value=load_balancer_port, expected_type=type_hints["load_balancer_port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if instance_port is not None:
                self._values["instance_port"] = instance_port
            if load_balancer_port is not None:
                self._values["load_balancer_port"] = load_balancer_port

        @builtins.property
        def instance_port(self) -> typing.Optional[jsii.Number]:
            '''[Classic Load Balancers] The back-end port for the listener.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancerlistener.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancerlistener-instanceport
            '''
            result = self._values.get("instance_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def load_balancer_port(self) -> typing.Optional[jsii.Number]:
            '''The port on which the load balancer is listening.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancerlistener.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancerlistener-loadbalancerport
            '''
            result = self._values.get("load_balancer_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisLoadBalancerListenerProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty",
        jsii_struct_bases=[],
        name_mapping={
            "address": "address",
            "availability_zone": "availabilityZone",
            "instance": "instance",
            "port": "port",
        },
    )
    class AnalysisLoadBalancerTargetProperty:
        def __init__(
            self,
            *,
            address: typing.Optional[builtins.str] = None,
            availability_zone: typing.Optional[builtins.str] = None,
            instance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            port: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a load balancer target.

            :param address: The IP address.
            :param availability_zone: The Availability Zone.
            :param instance: Information about the instance.
            :param port: The port on which the target is listening.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancertarget.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_load_balancer_target_property = ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty(
                    address="address",
                    availability_zone="availabilityZone",
                    instance=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__588df4fe383db28c254ac1e0b5038bf76c6595169cb8e1793603b7484a91f5f7)
                check_type(argname="argument address", value=address, expected_type=type_hints["address"])
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
                check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if address is not None:
                self._values["address"] = address
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if instance is not None:
                self._values["instance"] = instance
            if port is not None:
                self._values["port"] = port

        @builtins.property
        def address(self) -> typing.Optional[builtins.str]:
            '''The IP address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancertarget.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancertarget-address
            '''
            result = self._values.get("address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancertarget.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancertarget-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''Information about the instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancertarget.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancertarget-instance
            '''
            result = self._values.get("instance")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def port(self) -> typing.Optional[jsii.Number]:
            '''The port on which the target is listening.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisloadbalancertarget.html#cfn-ec2-networkinsightsanalysis-analysisloadbalancertarget-port
            '''
            result = self._values.get("port")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisLoadBalancerTargetProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty",
        jsii_struct_bases=[],
        name_mapping={
            "destination_addresses": "destinationAddresses",
            "destination_port_ranges": "destinationPortRanges",
            "protocol": "protocol",
            "source_addresses": "sourceAddresses",
            "source_port_ranges": "sourcePortRanges",
        },
    )
    class AnalysisPacketHeaderProperty:
        def __init__(
            self,
            *,
            destination_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
            destination_port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            protocol: typing.Optional[builtins.str] = None,
            source_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
            source_port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ) -> None:
            '''Describes a header.

            Reflects any changes made by a component as traffic passes through. The fields of an inbound header are null except for the first component of a path.

            :param destination_addresses: The destination addresses.
            :param destination_port_ranges: The destination port ranges.
            :param protocol: The protocol.
            :param source_addresses: The source addresses.
            :param source_port_ranges: The source port ranges.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_packet_header_property = ec2.CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty(
                    destination_addresses=["destinationAddresses"],
                    destination_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                        from=123,
                        to=123
                    )],
                    protocol="protocol",
                    source_addresses=["sourceAddresses"],
                    source_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                        from=123,
                        to=123
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__e1b9ed4cfdca71ae812afc237ce3637efdb06e9941b733aecb5d14b8c23e13e4)
                check_type(argname="argument destination_addresses", value=destination_addresses, expected_type=type_hints["destination_addresses"])
                check_type(argname="argument destination_port_ranges", value=destination_port_ranges, expected_type=type_hints["destination_port_ranges"])
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
                check_type(argname="argument source_addresses", value=source_addresses, expected_type=type_hints["source_addresses"])
                check_type(argname="argument source_port_ranges", value=source_port_ranges, expected_type=type_hints["source_port_ranges"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if destination_addresses is not None:
                self._values["destination_addresses"] = destination_addresses
            if destination_port_ranges is not None:
                self._values["destination_port_ranges"] = destination_port_ranges
            if protocol is not None:
                self._values["protocol"] = protocol
            if source_addresses is not None:
                self._values["source_addresses"] = source_addresses
            if source_port_ranges is not None:
                self._values["source_port_ranges"] = source_port_ranges

        @builtins.property
        def destination_addresses(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The destination addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html#cfn-ec2-networkinsightsanalysis-analysispacketheader-destinationaddresses
            '''
            result = self._values.get("destination_addresses")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def destination_port_ranges(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]]:
            '''The destination port ranges.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html#cfn-ec2-networkinsightsanalysis-analysispacketheader-destinationportranges
            '''
            result = self._values.get("destination_port_ranges")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]], result)

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html#cfn-ec2-networkinsightsanalysis-analysispacketheader-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_addresses(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The source addresses.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html#cfn-ec2-networkinsightsanalysis-analysispacketheader-sourceaddresses
            '''
            result = self._values.get("source_addresses")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def source_port_ranges(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]]:
            '''The source port ranges.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysispacketheader.html#cfn-ec2-networkinsightsanalysis-analysispacketheader-sourceportranges
            '''
            result = self._values.get("source_port_ranges")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisPacketHeaderProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty",
        jsii_struct_bases=[],
        name_mapping={
            "destination_cidr": "destinationCidr",
            "destination_prefix_list_id": "destinationPrefixListId",
            "egress_only_internet_gateway_id": "egressOnlyInternetGatewayId",
            "gateway_id": "gatewayId",
            "instance_id": "instanceId",
            "nat_gateway_id": "natGatewayId",
            "network_interface_id": "networkInterfaceId",
            "origin": "origin",
            "state": "state",
            "transit_gateway_id": "transitGatewayId",
            "vpc_peering_connection_id": "vpcPeeringConnectionId",
        },
    )
    class AnalysisRouteTableRouteProperty:
        def __init__(
            self,
            *,
            destination_cidr: typing.Optional[builtins.str] = None,
            destination_prefix_list_id: typing.Optional[builtins.str] = None,
            egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
            gateway_id: typing.Optional[builtins.str] = None,
            instance_id: typing.Optional[builtins.str] = None,
            nat_gateway_id: typing.Optional[builtins.str] = None,
            network_interface_id: typing.Optional[builtins.str] = None,
            origin: typing.Optional[builtins.str] = None,
            state: typing.Optional[builtins.str] = None,
            transit_gateway_id: typing.Optional[builtins.str] = None,
            vpc_peering_connection_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a route table route.

            :param destination_cidr: The destination IPv4 address, in CIDR notation.
            :param destination_prefix_list_id: The prefix of the AWS service .
            :param egress_only_internet_gateway_id: The ID of an egress-only internet gateway.
            :param gateway_id: The ID of the gateway, such as an internet gateway or virtual private gateway.
            :param instance_id: The ID of the instance, such as a NAT instance.
            :param nat_gateway_id: The ID of a NAT gateway.
            :param network_interface_id: The ID of a network interface.
            :param origin: Describes how the route was created. The following are the possible values:. - CreateRouteTable - The route was automatically created when the route table was created. - CreateRoute - The route was manually added to the route table. - EnableVgwRoutePropagation - The route was propagated by route propagation.
            :param state: The state. The following are the possible values:. - active - blackhole
            :param transit_gateway_id: The ID of a transit gateway.
            :param vpc_peering_connection_id: The ID of a VPC peering connection.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_route_table_route_property = ec2.CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty(
                    destination_cidr="destinationCidr",
                    destination_prefix_list_id="destinationPrefixListId",
                    egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
                    gateway_id="gatewayId",
                    instance_id="instanceId",
                    nat_gateway_id="natGatewayId",
                    network_interface_id="networkInterfaceId",
                    origin="origin",
                    state="state",
                    transit_gateway_id="transitGatewayId",
                    vpc_peering_connection_id="vpcPeeringConnectionId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1cab8f6f2694c19d64d18c42adfc7bcadf44aac28e3615ab8e4fb346560ae36d)
                check_type(argname="argument destination_cidr", value=destination_cidr, expected_type=type_hints["destination_cidr"])
                check_type(argname="argument destination_prefix_list_id", value=destination_prefix_list_id, expected_type=type_hints["destination_prefix_list_id"])
                check_type(argname="argument egress_only_internet_gateway_id", value=egress_only_internet_gateway_id, expected_type=type_hints["egress_only_internet_gateway_id"])
                check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
                check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
                check_type(argname="argument nat_gateway_id", value=nat_gateway_id, expected_type=type_hints["nat_gateway_id"])
                check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
                check_type(argname="argument origin", value=origin, expected_type=type_hints["origin"])
                check_type(argname="argument state", value=state, expected_type=type_hints["state"])
                check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
                check_type(argname="argument vpc_peering_connection_id", value=vpc_peering_connection_id, expected_type=type_hints["vpc_peering_connection_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if destination_cidr is not None:
                self._values["destination_cidr"] = destination_cidr
            if destination_prefix_list_id is not None:
                self._values["destination_prefix_list_id"] = destination_prefix_list_id
            if egress_only_internet_gateway_id is not None:
                self._values["egress_only_internet_gateway_id"] = egress_only_internet_gateway_id
            if gateway_id is not None:
                self._values["gateway_id"] = gateway_id
            if instance_id is not None:
                self._values["instance_id"] = instance_id
            if nat_gateway_id is not None:
                self._values["nat_gateway_id"] = nat_gateway_id
            if network_interface_id is not None:
                self._values["network_interface_id"] = network_interface_id
            if origin is not None:
                self._values["origin"] = origin
            if state is not None:
                self._values["state"] = state
            if transit_gateway_id is not None:
                self._values["transit_gateway_id"] = transit_gateway_id
            if vpc_peering_connection_id is not None:
                self._values["vpc_peering_connection_id"] = vpc_peering_connection_id

        @builtins.property
        def destination_cidr(self) -> typing.Optional[builtins.str]:
            '''The destination IPv4 address, in CIDR notation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-destinationcidr
            '''
            result = self._values.get("destination_cidr")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
            '''The prefix of the AWS service .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-destinationprefixlistid
            '''
            result = self._values.get("destination_prefix_list_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def egress_only_internet_gateway_id(self) -> typing.Optional[builtins.str]:
            '''The ID of an egress-only internet gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-egressonlyinternetgatewayid
            '''
            result = self._values.get("egress_only_internet_gateway_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def gateway_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the gateway, such as an internet gateway or virtual private gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-gatewayid
            '''
            result = self._values.get("gateway_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the instance, such as a NAT instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-instanceid
            '''
            result = self._values.get("instance_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def nat_gateway_id(self) -> typing.Optional[builtins.str]:
            '''The ID of a NAT gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-natgatewayid
            '''
            result = self._values.get("nat_gateway_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def network_interface_id(self) -> typing.Optional[builtins.str]:
            '''The ID of a network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-networkinterfaceid
            '''
            result = self._values.get("network_interface_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def origin(self) -> typing.Optional[builtins.str]:
            '''Describes how the route was created. The following are the possible values:.

            - CreateRouteTable - The route was automatically created when the route table was created.
            - CreateRoute - The route was manually added to the route table.
            - EnableVgwRoutePropagation - The route was propagated by route propagation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-origin
            '''
            result = self._values.get("origin")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def state(self) -> typing.Optional[builtins.str]:
            '''The state. The following are the possible values:.

            - active
            - blackhole

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-state
            '''
            result = self._values.get("state")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def transit_gateway_id(self) -> typing.Optional[builtins.str]:
            '''The ID of a transit gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-transitgatewayid
            '''
            result = self._values.get("transit_gateway_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def vpc_peering_connection_id(self) -> typing.Optional[builtins.str]:
            '''The ID of a VPC peering connection.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysisroutetableroute.html#cfn-ec2-networkinsightsanalysis-analysisroutetableroute-vpcpeeringconnectionid
            '''
            result = self._values.get("vpc_peering_connection_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisRouteTableRouteProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty",
        jsii_struct_bases=[],
        name_mapping={
            "cidr": "cidr",
            "direction": "direction",
            "port_range": "portRange",
            "prefix_list_id": "prefixListId",
            "protocol": "protocol",
            "security_group_id": "securityGroupId",
        },
    )
    class AnalysisSecurityGroupRuleProperty:
        def __init__(
            self,
            *,
            cidr: typing.Optional[builtins.str] = None,
            direction: typing.Optional[builtins.str] = None,
            port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            prefix_list_id: typing.Optional[builtins.str] = None,
            protocol: typing.Optional[builtins.str] = None,
            security_group_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a security group rule.

            :param cidr: The IPv4 address range, in CIDR notation.
            :param direction: The direction. The following are the possible values:. - egress - ingress
            :param port_range: The port range.
            :param prefix_list_id: The prefix list ID.
            :param protocol: The protocol name.
            :param security_group_id: The security group ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                analysis_security_group_rule_property = ec2.CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty(
                    cidr="cidr",
                    direction="direction",
                    port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                        from=123,
                        to=123
                    ),
                    prefix_list_id="prefixListId",
                    protocol="protocol",
                    security_group_id="securityGroupId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__eadc9a243462ce71c1e75b40c5188e1a6f0628d56b7ea73d3419ae8d6aafed6a)
                check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
                check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
                check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
                check_type(argname="argument prefix_list_id", value=prefix_list_id, expected_type=type_hints["prefix_list_id"])
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
                check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if cidr is not None:
                self._values["cidr"] = cidr
            if direction is not None:
                self._values["direction"] = direction
            if port_range is not None:
                self._values["port_range"] = port_range
            if prefix_list_id is not None:
                self._values["prefix_list_id"] = prefix_list_id
            if protocol is not None:
                self._values["protocol"] = protocol
            if security_group_id is not None:
                self._values["security_group_id"] = security_group_id

        @builtins.property
        def cidr(self) -> typing.Optional[builtins.str]:
            '''The IPv4 address range, in CIDR notation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-cidr
            '''
            result = self._values.get("cidr")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def direction(self) -> typing.Optional[builtins.str]:
            '''The direction. The following are the possible values:.

            - egress
            - ingress

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-direction
            '''
            result = self._values.get("direction")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def port_range(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]:
            '''The port range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-portrange
            '''
            result = self._values.get("port_range")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]], result)

        @builtins.property
        def prefix_list_id(self) -> typing.Optional[builtins.str]:
            '''The prefix list ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-prefixlistid
            '''
            result = self._values.get("prefix_list_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The protocol name.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def security_group_id(self) -> typing.Optional[builtins.str]:
            '''The security group ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-analysissecuritygrouprule.html#cfn-ec2-networkinsightsanalysis-analysissecuritygrouprule-securitygroupid
            '''
            result = self._values.get("security_group_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AnalysisSecurityGroupRuleProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.ExplanationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "acl": "acl",
            "acl_rule": "aclRule",
            "address": "address",
            "addresses": "addresses",
            "attached_to": "attachedTo",
            "availability_zones": "availabilityZones",
            "cidrs": "cidrs",
            "classic_load_balancer_listener": "classicLoadBalancerListener",
            "component": "component",
            "component_account": "componentAccount",
            "component_region": "componentRegion",
            "customer_gateway": "customerGateway",
            "destination": "destination",
            "destination_vpc": "destinationVpc",
            "direction": "direction",
            "elastic_load_balancer_listener": "elasticLoadBalancerListener",
            "explanation_code": "explanationCode",
            "ingress_route_table": "ingressRouteTable",
            "internet_gateway": "internetGateway",
            "load_balancer_arn": "loadBalancerArn",
            "load_balancer_listener_port": "loadBalancerListenerPort",
            "load_balancer_target": "loadBalancerTarget",
            "load_balancer_target_group": "loadBalancerTargetGroup",
            "load_balancer_target_groups": "loadBalancerTargetGroups",
            "load_balancer_target_port": "loadBalancerTargetPort",
            "missing_component": "missingComponent",
            "nat_gateway": "natGateway",
            "network_interface": "networkInterface",
            "packet_field": "packetField",
            "port": "port",
            "port_ranges": "portRanges",
            "prefix_list": "prefixList",
            "protocols": "protocols",
            "route_table": "routeTable",
            "route_table_route": "routeTableRoute",
            "security_group": "securityGroup",
            "security_group_rule": "securityGroupRule",
            "security_groups": "securityGroups",
            "source_vpc": "sourceVpc",
            "state": "state",
            "subnet": "subnet",
            "subnet_route_table": "subnetRouteTable",
            "transit_gateway": "transitGateway",
            "transit_gateway_attachment": "transitGatewayAttachment",
            "transit_gateway_route_table": "transitGatewayRouteTable",
            "transit_gateway_route_table_route": "transitGatewayRouteTableRoute",
            "vpc": "vpc",
            "vpc_endpoint": "vpcEndpoint",
            "vpc_peering_connection": "vpcPeeringConnection",
            "vpn_connection": "vpnConnection",
            "vpn_gateway": "vpnGateway",
        },
    )
    class ExplanationProperty:
        def __init__(
            self,
            *,
            acl: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            acl_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            address: typing.Optional[builtins.str] = None,
            addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
            attached_to: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
            cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
            classic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            component_account: typing.Optional[builtins.str] = None,
            component_region: typing.Optional[builtins.str] = None,
            customer_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            destination_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            direction: typing.Optional[builtins.str] = None,
            elastic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            explanation_code: typing.Optional[builtins.str] = None,
            ingress_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            internet_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            load_balancer_arn: typing.Optional[builtins.str] = None,
            load_balancer_listener_port: typing.Optional[jsii.Number] = None,
            load_balancer_target: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            load_balancer_target_group: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            load_balancer_target_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            load_balancer_target_port: typing.Optional[jsii.Number] = None,
            missing_component: typing.Optional[builtins.str] = None,
            nat_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interface: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            packet_field: typing.Optional[builtins.str] = None,
            port: typing.Optional[jsii.Number] = None,
            port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            prefix_list: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            protocols: typing.Optional[typing.Sequence[builtins.str]] = None,
            route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            security_group: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            security_group_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            security_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            source_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            state: typing.Optional[builtins.str] = None,
            subnet: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            subnet_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway_attachment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway_route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpc_endpoint: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpc_peering_connection: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpn_connection: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpn_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes an explanation code for an unreachable path.

            For more information, see `Reachability Analyzer explanation codes <https://docs.aws.amazon.com/vpc/latest/reachability/explanation-codes.html>`_ .

            :param acl: The network ACL.
            :param acl_rule: The network ACL rule.
            :param address: The IPv4 address, in CIDR notation.
            :param addresses: The IPv4 addresses, in CIDR notation.
            :param attached_to: The resource to which the component is attached.
            :param availability_zones: The Availability Zones.
            :param cidrs: The CIDR ranges.
            :param classic_load_balancer_listener: The listener for a Classic Load Balancer.
            :param component: The component.
            :param component_account: The AWS account for the component.
            :param component_region: The Region for the component.
            :param customer_gateway: The customer gateway.
            :param destination: The destination.
            :param destination_vpc: The destination VPC.
            :param direction: The direction. The following are the possible values:. - egress - ingress
            :param elastic_load_balancer_listener: The load balancer listener.
            :param explanation_code: The explanation code.
            :param ingress_route_table: The route table.
            :param internet_gateway: The internet gateway.
            :param load_balancer_arn: The Amazon Resource Name (ARN) of the load balancer.
            :param load_balancer_listener_port: The listener port of the load balancer.
            :param load_balancer_target: The target.
            :param load_balancer_target_group: The target group.
            :param load_balancer_target_groups: The target groups.
            :param load_balancer_target_port: The target port.
            :param missing_component: The missing component.
            :param nat_gateway: The NAT gateway.
            :param network_interface: The network interface.
            :param packet_field: The packet field.
            :param port: The port.
            :param port_ranges: The port ranges.
            :param prefix_list: The prefix list.
            :param protocols: The protocols.
            :param route_table: The route table.
            :param route_table_route: The route table route.
            :param security_group: The security group.
            :param security_group_rule: The security group rule.
            :param security_groups: The security groups.
            :param source_vpc: The source VPC.
            :param state: The state.
            :param subnet: The subnet.
            :param subnet_route_table: The route table for the subnet.
            :param transit_gateway: The transit gateway.
            :param transit_gateway_attachment: The transit gateway attachment.
            :param transit_gateway_route_table: The transit gateway route table.
            :param transit_gateway_route_table_route: The transit gateway route table route.
            :param vpc: The component VPC.
            :param vpc_endpoint: The VPC endpoint.
            :param vpc_peering_connection: The VPC peering connection.
            :param vpn_connection: The VPN connection.
            :param vpn_gateway: The VPN gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                explanation_property = ec2.CfnNetworkInsightsAnalysis.ExplanationProperty(
                    acl=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    acl_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty(
                        cidr="cidr",
                        egress=False,
                        port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        ),
                        protocol="protocol",
                        rule_action="ruleAction",
                        rule_number=123
                    ),
                    address="address",
                    addresses=["addresses"],
                    attached_to=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    availability_zones=["availabilityZones"],
                    cidrs=["cidrs"],
                    classic_load_balancer_listener=ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty(
                        instance_port=123,
                        load_balancer_port=123
                    ),
                    component=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    component_account="componentAccount",
                    component_region="componentRegion",
                    customer_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    destination=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    destination_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    direction="direction",
                    elastic_load_balancer_listener=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    explanation_code="explanationCode",
                    ingress_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    internet_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    load_balancer_arn="loadBalancerArn",
                    load_balancer_listener_port=123,
                    load_balancer_target=ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty(
                        address="address",
                        availability_zone="availabilityZone",
                        instance=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        port=123
                    ),
                    load_balancer_target_group=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    load_balancer_target_groups=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    )],
                    load_balancer_target_port=123,
                    missing_component="missingComponent",
                    nat_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    network_interface=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    packet_field="packetField",
                    port=123,
                    port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                        from=123,
                        to=123
                    )],
                    prefix_list=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    protocols=["protocols"],
                    route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    route_table_route=ec2.CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty(
                        destination_cidr="destinationCidr",
                        destination_prefix_list_id="destinationPrefixListId",
                        egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
                        gateway_id="gatewayId",
                        instance_id="instanceId",
                        nat_gateway_id="natGatewayId",
                        network_interface_id="networkInterfaceId",
                        origin="origin",
                        state="state",
                        transit_gateway_id="transitGatewayId",
                        vpc_peering_connection_id="vpcPeeringConnectionId"
                    ),
                    security_group=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    security_group_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty(
                        cidr="cidr",
                        direction="direction",
                        port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        ),
                        prefix_list_id="prefixListId",
                        protocol="protocol",
                        security_group_id="securityGroupId"
                    ),
                    security_groups=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    )],
                    source_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    state="state",
                    subnet=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    subnet_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway_attachment=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway_route_table_route=ec2.CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty(
                        attachment_id="attachmentId",
                        destination_cidr="destinationCidr",
                        prefix_list_id="prefixListId",
                        resource_id="resourceId",
                        resource_type="resourceType",
                        route_origin="routeOrigin",
                        state="state"
                    ),
                    vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    vpc_endpoint=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    vpc_peering_connection=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    vpn_connection=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    vpn_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ed8878c4db91bf6a50590fb78c80ba9f44606a81d0075bc1b9a4b4f11d789ef9)
                check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
                check_type(argname="argument acl_rule", value=acl_rule, expected_type=type_hints["acl_rule"])
                check_type(argname="argument address", value=address, expected_type=type_hints["address"])
                check_type(argname="argument addresses", value=addresses, expected_type=type_hints["addresses"])
                check_type(argname="argument attached_to", value=attached_to, expected_type=type_hints["attached_to"])
                check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
                check_type(argname="argument cidrs", value=cidrs, expected_type=type_hints["cidrs"])
                check_type(argname="argument classic_load_balancer_listener", value=classic_load_balancer_listener, expected_type=type_hints["classic_load_balancer_listener"])
                check_type(argname="argument component", value=component, expected_type=type_hints["component"])
                check_type(argname="argument component_account", value=component_account, expected_type=type_hints["component_account"])
                check_type(argname="argument component_region", value=component_region, expected_type=type_hints["component_region"])
                check_type(argname="argument customer_gateway", value=customer_gateway, expected_type=type_hints["customer_gateway"])
                check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
                check_type(argname="argument destination_vpc", value=destination_vpc, expected_type=type_hints["destination_vpc"])
                check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
                check_type(argname="argument elastic_load_balancer_listener", value=elastic_load_balancer_listener, expected_type=type_hints["elastic_load_balancer_listener"])
                check_type(argname="argument explanation_code", value=explanation_code, expected_type=type_hints["explanation_code"])
                check_type(argname="argument ingress_route_table", value=ingress_route_table, expected_type=type_hints["ingress_route_table"])
                check_type(argname="argument internet_gateway", value=internet_gateway, expected_type=type_hints["internet_gateway"])
                check_type(argname="argument load_balancer_arn", value=load_balancer_arn, expected_type=type_hints["load_balancer_arn"])
                check_type(argname="argument load_balancer_listener_port", value=load_balancer_listener_port, expected_type=type_hints["load_balancer_listener_port"])
                check_type(argname="argument load_balancer_target", value=load_balancer_target, expected_type=type_hints["load_balancer_target"])
                check_type(argname="argument load_balancer_target_group", value=load_balancer_target_group, expected_type=type_hints["load_balancer_target_group"])
                check_type(argname="argument load_balancer_target_groups", value=load_balancer_target_groups, expected_type=type_hints["load_balancer_target_groups"])
                check_type(argname="argument load_balancer_target_port", value=load_balancer_target_port, expected_type=type_hints["load_balancer_target_port"])
                check_type(argname="argument missing_component", value=missing_component, expected_type=type_hints["missing_component"])
                check_type(argname="argument nat_gateway", value=nat_gateway, expected_type=type_hints["nat_gateway"])
                check_type(argname="argument network_interface", value=network_interface, expected_type=type_hints["network_interface"])
                check_type(argname="argument packet_field", value=packet_field, expected_type=type_hints["packet_field"])
                check_type(argname="argument port", value=port, expected_type=type_hints["port"])
                check_type(argname="argument port_ranges", value=port_ranges, expected_type=type_hints["port_ranges"])
                check_type(argname="argument prefix_list", value=prefix_list, expected_type=type_hints["prefix_list"])
                check_type(argname="argument protocols", value=protocols, expected_type=type_hints["protocols"])
                check_type(argname="argument route_table", value=route_table, expected_type=type_hints["route_table"])
                check_type(argname="argument route_table_route", value=route_table_route, expected_type=type_hints["route_table_route"])
                check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
                check_type(argname="argument security_group_rule", value=security_group_rule, expected_type=type_hints["security_group_rule"])
                check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
                check_type(argname="argument source_vpc", value=source_vpc, expected_type=type_hints["source_vpc"])
                check_type(argname="argument state", value=state, expected_type=type_hints["state"])
                check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
                check_type(argname="argument subnet_route_table", value=subnet_route_table, expected_type=type_hints["subnet_route_table"])
                check_type(argname="argument transit_gateway", value=transit_gateway, expected_type=type_hints["transit_gateway"])
                check_type(argname="argument transit_gateway_attachment", value=transit_gateway_attachment, expected_type=type_hints["transit_gateway_attachment"])
                check_type(argname="argument transit_gateway_route_table", value=transit_gateway_route_table, expected_type=type_hints["transit_gateway_route_table"])
                check_type(argname="argument transit_gateway_route_table_route", value=transit_gateway_route_table_route, expected_type=type_hints["transit_gateway_route_table_route"])
                check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
                check_type(argname="argument vpc_endpoint", value=vpc_endpoint, expected_type=type_hints["vpc_endpoint"])
                check_type(argname="argument vpc_peering_connection", value=vpc_peering_connection, expected_type=type_hints["vpc_peering_connection"])
                check_type(argname="argument vpn_connection", value=vpn_connection, expected_type=type_hints["vpn_connection"])
                check_type(argname="argument vpn_gateway", value=vpn_gateway, expected_type=type_hints["vpn_gateway"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if acl is not None:
                self._values["acl"] = acl
            if acl_rule is not None:
                self._values["acl_rule"] = acl_rule
            if address is not None:
                self._values["address"] = address
            if addresses is not None:
                self._values["addresses"] = addresses
            if attached_to is not None:
                self._values["attached_to"] = attached_to
            if availability_zones is not None:
                self._values["availability_zones"] = availability_zones
            if cidrs is not None:
                self._values["cidrs"] = cidrs
            if classic_load_balancer_listener is not None:
                self._values["classic_load_balancer_listener"] = classic_load_balancer_listener
            if component is not None:
                self._values["component"] = component
            if component_account is not None:
                self._values["component_account"] = component_account
            if component_region is not None:
                self._values["component_region"] = component_region
            if customer_gateway is not None:
                self._values["customer_gateway"] = customer_gateway
            if destination is not None:
                self._values["destination"] = destination
            if destination_vpc is not None:
                self._values["destination_vpc"] = destination_vpc
            if direction is not None:
                self._values["direction"] = direction
            if elastic_load_balancer_listener is not None:
                self._values["elastic_load_balancer_listener"] = elastic_load_balancer_listener
            if explanation_code is not None:
                self._values["explanation_code"] = explanation_code
            if ingress_route_table is not None:
                self._values["ingress_route_table"] = ingress_route_table
            if internet_gateway is not None:
                self._values["internet_gateway"] = internet_gateway
            if load_balancer_arn is not None:
                self._values["load_balancer_arn"] = load_balancer_arn
            if load_balancer_listener_port is not None:
                self._values["load_balancer_listener_port"] = load_balancer_listener_port
            if load_balancer_target is not None:
                self._values["load_balancer_target"] = load_balancer_target
            if load_balancer_target_group is not None:
                self._values["load_balancer_target_group"] = load_balancer_target_group
            if load_balancer_target_groups is not None:
                self._values["load_balancer_target_groups"] = load_balancer_target_groups
            if load_balancer_target_port is not None:
                self._values["load_balancer_target_port"] = load_balancer_target_port
            if missing_component is not None:
                self._values["missing_component"] = missing_component
            if nat_gateway is not None:
                self._values["nat_gateway"] = nat_gateway
            if network_interface is not None:
                self._values["network_interface"] = network_interface
            if packet_field is not None:
                self._values["packet_field"] = packet_field
            if port is not None:
                self._values["port"] = port
            if port_ranges is not None:
                self._values["port_ranges"] = port_ranges
            if prefix_list is not None:
                self._values["prefix_list"] = prefix_list
            if protocols is not None:
                self._values["protocols"] = protocols
            if route_table is not None:
                self._values["route_table"] = route_table
            if route_table_route is not None:
                self._values["route_table_route"] = route_table_route
            if security_group is not None:
                self._values["security_group"] = security_group
            if security_group_rule is not None:
                self._values["security_group_rule"] = security_group_rule
            if security_groups is not None:
                self._values["security_groups"] = security_groups
            if source_vpc is not None:
                self._values["source_vpc"] = source_vpc
            if state is not None:
                self._values["state"] = state
            if subnet is not None:
                self._values["subnet"] = subnet
            if subnet_route_table is not None:
                self._values["subnet_route_table"] = subnet_route_table
            if transit_gateway is not None:
                self._values["transit_gateway"] = transit_gateway
            if transit_gateway_attachment is not None:
                self._values["transit_gateway_attachment"] = transit_gateway_attachment
            if transit_gateway_route_table is not None:
                self._values["transit_gateway_route_table"] = transit_gateway_route_table
            if transit_gateway_route_table_route is not None:
                self._values["transit_gateway_route_table_route"] = transit_gateway_route_table_route
            if vpc is not None:
                self._values["vpc"] = vpc
            if vpc_endpoint is not None:
                self._values["vpc_endpoint"] = vpc_endpoint
            if vpc_peering_connection is not None:
                self._values["vpc_peering_connection"] = vpc_peering_connection
            if vpn_connection is not None:
                self._values["vpn_connection"] = vpn_connection
            if vpn_gateway is not None:
                self._values["vpn_gateway"] = vpn_gateway

        @builtins.property
        def acl(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The network ACL.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-acl
            '''
            result = self._values.get("acl")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def acl_rule(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty"]]:
            '''The network ACL rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-aclrule
            '''
            result = self._values.get("acl_rule")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty"]], result)

        @builtins.property
        def address(self) -> typing.Optional[builtins.str]:
            '''The IPv4 address, in CIDR notation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-address
            '''
            result = self._values.get("address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def addresses(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IPv4 addresses, in CIDR notation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-addresses
            '''
            result = self._values.get("addresses")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def attached_to(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The resource to which the component is attached.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-attachedto
            '''
            result = self._values.get("attached_to")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def availability_zones(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The Availability Zones.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-availabilityzones
            '''
            result = self._values.get("availability_zones")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The CIDR ranges.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-cidrs
            '''
            result = self._values.get("cidrs")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def classic_load_balancer_listener(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty"]]:
            '''The listener for a Classic Load Balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-classicloadbalancerlistener
            '''
            result = self._values.get("classic_load_balancer_listener")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty"]], result)

        @builtins.property
        def component(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-component
            '''
            result = self._values.get("component")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def component_account(self) -> typing.Optional[builtins.str]:
            '''The AWS account for the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-componentaccount
            '''
            result = self._values.get("component_account")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def component_region(self) -> typing.Optional[builtins.str]:
            '''The Region for the component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-componentregion
            '''
            result = self._values.get("component_region")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def customer_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The customer gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-customergateway
            '''
            result = self._values.get("customer_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def destination(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The destination.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-destination
            '''
            result = self._values.get("destination")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def destination_vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The destination VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-destinationvpc
            '''
            result = self._values.get("destination_vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def direction(self) -> typing.Optional[builtins.str]:
            '''The direction. The following are the possible values:.

            - egress
            - ingress

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-direction
            '''
            result = self._values.get("direction")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def elastic_load_balancer_listener(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The load balancer listener.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-elasticloadbalancerlistener
            '''
            result = self._values.get("elastic_load_balancer_listener")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def explanation_code(self) -> typing.Optional[builtins.str]:
            '''The explanation code.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-explanationcode
            '''
            result = self._values.get("explanation_code")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ingress_route_table(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The route table.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-ingressroutetable
            '''
            result = self._values.get("ingress_route_table")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def internet_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The internet gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-internetgateway
            '''
            result = self._values.get("internet_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def load_balancer_arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the load balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancerarn
            '''
            result = self._values.get("load_balancer_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def load_balancer_listener_port(self) -> typing.Optional[jsii.Number]:
            '''The listener port of the load balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancerlistenerport
            '''
            result = self._values.get("load_balancer_listener_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def load_balancer_target(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty"]]:
            '''The target.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancertarget
            '''
            result = self._values.get("load_balancer_target")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty"]], result)

        @builtins.property
        def load_balancer_target_group(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The target group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancertargetgroup
            '''
            result = self._values.get("load_balancer_target_group")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def load_balancer_target_groups(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]]:
            '''The target groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancertargetgroups
            '''
            result = self._values.get("load_balancer_target_groups")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]], result)

        @builtins.property
        def load_balancer_target_port(self) -> typing.Optional[jsii.Number]:
            '''The target port.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-loadbalancertargetport
            '''
            result = self._values.get("load_balancer_target_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def missing_component(self) -> typing.Optional[builtins.str]:
            '''The missing component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-missingcomponent
            '''
            result = self._values.get("missing_component")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def nat_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The NAT gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-natgateway
            '''
            result = self._values.get("nat_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def network_interface(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-networkinterface
            '''
            result = self._values.get("network_interface")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def packet_field(self) -> typing.Optional[builtins.str]:
            '''The packet field.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-packetfield
            '''
            result = self._values.get("packet_field")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def port(self) -> typing.Optional[jsii.Number]:
            '''The port.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-port
            '''
            result = self._values.get("port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def port_ranges(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]]:
            '''The port ranges.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-portranges
            '''
            result = self._values.get("port_ranges")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.PortRangeProperty"]]]], result)

        @builtins.property
        def prefix_list(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The prefix list.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-prefixlist
            '''
            result = self._values.get("prefix_list")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def protocols(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The protocols.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-protocols
            '''
            result = self._values.get("protocols")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def route_table(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The route table.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-routetable
            '''
            result = self._values.get("route_table")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def route_table_route(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty"]]:
            '''The route table route.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-routetableroute
            '''
            result = self._values.get("route_table_route")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty"]], result)

        @builtins.property
        def security_group(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The security group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-securitygroup
            '''
            result = self._values.get("security_group")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def security_group_rule(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty"]]:
            '''The security group rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-securitygrouprule
            '''
            result = self._values.get("security_group_rule")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty"]], result)

        @builtins.property
        def security_groups(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]]:
            '''The security groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-securitygroups
            '''
            result = self._values.get("security_groups")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]]], result)

        @builtins.property
        def source_vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The source VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-sourcevpc
            '''
            result = self._values.get("source_vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def state(self) -> typing.Optional[builtins.str]:
            '''The state.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-state
            '''
            result = self._values.get("state")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def subnet(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The subnet.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-subnet
            '''
            result = self._values.get("subnet")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def subnet_route_table(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The route table for the subnet.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-subnetroutetable
            '''
            result = self._values.get("subnet_route_table")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The transit gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-transitgateway
            '''
            result = self._values.get("transit_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway_attachment(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The transit gateway attachment.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-transitgatewayattachment
            '''
            result = self._values.get("transit_gateway_attachment")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway_route_table(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The transit gateway route table.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-transitgatewayroutetable
            '''
            result = self._values.get("transit_gateway_route_table")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway_route_table_route(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty"]]:
            '''The transit gateway route table route.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-transitgatewayroutetableroute
            '''
            result = self._values.get("transit_gateway_route_table_route")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty"]], result)

        @builtins.property
        def vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The component VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-vpc
            '''
            result = self._values.get("vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def vpc_endpoint(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The VPC endpoint.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-vpcendpoint
            '''
            result = self._values.get("vpc_endpoint")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def vpc_peering_connection(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The VPC peering connection.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-vpcpeeringconnection
            '''
            result = self._values.get("vpc_peering_connection")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def vpn_connection(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The VPN connection.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-vpnconnection
            '''
            result = self._values.get("vpn_connection")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def vpn_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The VPN gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-explanation.html#cfn-ec2-networkinsightsanalysis-explanation-vpngateway
            '''
            result = self._values.get("vpn_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ExplanationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.PathComponentProperty",
        jsii_struct_bases=[],
        name_mapping={
            "acl_rule": "aclRule",
            "additional_details": "additionalDetails",
            "component": "component",
            "destination_vpc": "destinationVpc",
            "elastic_load_balancer_listener": "elasticLoadBalancerListener",
            "explanations": "explanations",
            "inbound_header": "inboundHeader",
            "outbound_header": "outboundHeader",
            "route_table_route": "routeTableRoute",
            "security_group_rule": "securityGroupRule",
            "sequence_number": "sequenceNumber",
            "service_name": "serviceName",
            "source_vpc": "sourceVpc",
            "subnet": "subnet",
            "transit_gateway": "transitGateway",
            "transit_gateway_route_table_route": "transitGatewayRouteTableRoute",
            "vpc": "vpc",
        },
    )
    class PathComponentProperty:
        def __init__(
            self,
            *,
            acl_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            additional_details: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AdditionalDetailProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            destination_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            elastic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            explanations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.ExplanationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            inbound_header: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            outbound_header: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            security_group_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            sequence_number: typing.Optional[jsii.Number] = None,
            service_name: typing.Optional[builtins.str] = None,
            source_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            subnet: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            transit_gateway_route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsAnalysis.AnalysisComponentProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes a path component.

            :param acl_rule: The network ACL rule.
            :param additional_details: The additional details.
            :param component: The component.
            :param destination_vpc: The destination VPC.
            :param elastic_load_balancer_listener: The load balancer listener.
            :param explanations: The explanation codes.
            :param inbound_header: The inbound header.
            :param outbound_header: The outbound header.
            :param route_table_route: The route table route.
            :param security_group_rule: The security group rule.
            :param sequence_number: The sequence number.
            :param service_name: The name of the VPC endpoint service.
            :param source_vpc: The source VPC.
            :param subnet: The subnet.
            :param transit_gateway: The transit gateway.
            :param transit_gateway_route_table_route: The route in a transit gateway route table.
            :param vpc: The component VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                path_component_property = ec2.CfnNetworkInsightsAnalysis.PathComponentProperty(
                    acl_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty(
                        cidr="cidr",
                        egress=False,
                        port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        ),
                        protocol="protocol",
                        rule_action="ruleAction",
                        rule_number=123
                    ),
                    additional_details=[ec2.CfnNetworkInsightsAnalysis.AdditionalDetailProperty(
                        additional_detail_type="additionalDetailType",
                        component=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        load_balancers=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        )],
                        service_name="serviceName"
                    )],
                    component=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    destination_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    elastic_load_balancer_listener=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    explanations=[ec2.CfnNetworkInsightsAnalysis.ExplanationProperty(
                        acl=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        acl_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty(
                            cidr="cidr",
                            egress=False,
                            port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                                from=123,
                                to=123
                            ),
                            protocol="protocol",
                            rule_action="ruleAction",
                            rule_number=123
                        ),
                        address="address",
                        addresses=["addresses"],
                        attached_to=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        availability_zones=["availabilityZones"],
                        cidrs=["cidrs"],
                        classic_load_balancer_listener=ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty(
                            instance_port=123,
                            load_balancer_port=123
                        ),
                        component=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        component_account="componentAccount",
                        component_region="componentRegion",
                        customer_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        destination=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        destination_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        direction="direction",
                        elastic_load_balancer_listener=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        explanation_code="explanationCode",
                        ingress_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        internet_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        load_balancer_arn="loadBalancerArn",
                        load_balancer_listener_port=123,
                        load_balancer_target=ec2.CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty(
                            address="address",
                            availability_zone="availabilityZone",
                            instance=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                                arn="arn",
                                id="id"
                            ),
                            port=123
                        ),
                        load_balancer_target_group=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        load_balancer_target_groups=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        )],
                        load_balancer_target_port=123,
                        missing_component="missingComponent",
                        nat_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        network_interface=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        packet_field="packetField",
                        port=123,
                        port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        )],
                        prefix_list=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        protocols=["protocols"],
                        route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        route_table_route=ec2.CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty(
                            destination_cidr="destinationCidr",
                            destination_prefix_list_id="destinationPrefixListId",
                            egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
                            gateway_id="gatewayId",
                            instance_id="instanceId",
                            nat_gateway_id="natGatewayId",
                            network_interface_id="networkInterfaceId",
                            origin="origin",
                            state="state",
                            transit_gateway_id="transitGatewayId",
                            vpc_peering_connection_id="vpcPeeringConnectionId"
                        ),
                        security_group=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        security_group_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty(
                            cidr="cidr",
                            direction="direction",
                            port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                                from=123,
                                to=123
                            ),
                            prefix_list_id="prefixListId",
                            protocol="protocol",
                            security_group_id="securityGroupId"
                        ),
                        security_groups=[ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        )],
                        source_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        state="state",
                        subnet=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        subnet_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        transit_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        transit_gateway_attachment=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        transit_gateway_route_table=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        transit_gateway_route_table_route=ec2.CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty(
                            attachment_id="attachmentId",
                            destination_cidr="destinationCidr",
                            prefix_list_id="prefixListId",
                            resource_id="resourceId",
                            resource_type="resourceType",
                            route_origin="routeOrigin",
                            state="state"
                        ),
                        vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        vpc_endpoint=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        vpc_peering_connection=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        vpn_connection=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        ),
                        vpn_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                            arn="arn",
                            id="id"
                        )
                    )],
                    inbound_header=ec2.CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        )],
                        protocol="protocol",
                        source_addresses=["sourceAddresses"],
                        source_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        )]
                    ),
                    outbound_header=ec2.CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty(
                        destination_addresses=["destinationAddresses"],
                        destination_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        )],
                        protocol="protocol",
                        source_addresses=["sourceAddresses"],
                        source_port_ranges=[ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        )]
                    ),
                    route_table_route=ec2.CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty(
                        destination_cidr="destinationCidr",
                        destination_prefix_list_id="destinationPrefixListId",
                        egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
                        gateway_id="gatewayId",
                        instance_id="instanceId",
                        nat_gateway_id="natGatewayId",
                        network_interface_id="networkInterfaceId",
                        origin="origin",
                        state="state",
                        transit_gateway_id="transitGatewayId",
                        vpc_peering_connection_id="vpcPeeringConnectionId"
                    ),
                    security_group_rule=ec2.CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty(
                        cidr="cidr",
                        direction="direction",
                        port_range=ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                            from=123,
                            to=123
                        ),
                        prefix_list_id="prefixListId",
                        protocol="protocol",
                        security_group_id="securityGroupId"
                    ),
                    sequence_number=123,
                    service_name="serviceName",
                    source_vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    subnet=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    ),
                    transit_gateway_route_table_route=ec2.CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty(
                        attachment_id="attachmentId",
                        destination_cidr="destinationCidr",
                        prefix_list_id="prefixListId",
                        resource_id="resourceId",
                        resource_type="resourceType",
                        route_origin="routeOrigin",
                        state="state"
                    ),
                    vpc=ec2.CfnNetworkInsightsAnalysis.AnalysisComponentProperty(
                        arn="arn",
                        id="id"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8aba4747fa922bc0165e7923b126d79994a2328fbccffe6312921668d032818c)
                check_type(argname="argument acl_rule", value=acl_rule, expected_type=type_hints["acl_rule"])
                check_type(argname="argument additional_details", value=additional_details, expected_type=type_hints["additional_details"])
                check_type(argname="argument component", value=component, expected_type=type_hints["component"])
                check_type(argname="argument destination_vpc", value=destination_vpc, expected_type=type_hints["destination_vpc"])
                check_type(argname="argument elastic_load_balancer_listener", value=elastic_load_balancer_listener, expected_type=type_hints["elastic_load_balancer_listener"])
                check_type(argname="argument explanations", value=explanations, expected_type=type_hints["explanations"])
                check_type(argname="argument inbound_header", value=inbound_header, expected_type=type_hints["inbound_header"])
                check_type(argname="argument outbound_header", value=outbound_header, expected_type=type_hints["outbound_header"])
                check_type(argname="argument route_table_route", value=route_table_route, expected_type=type_hints["route_table_route"])
                check_type(argname="argument security_group_rule", value=security_group_rule, expected_type=type_hints["security_group_rule"])
                check_type(argname="argument sequence_number", value=sequence_number, expected_type=type_hints["sequence_number"])
                check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
                check_type(argname="argument source_vpc", value=source_vpc, expected_type=type_hints["source_vpc"])
                check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
                check_type(argname="argument transit_gateway", value=transit_gateway, expected_type=type_hints["transit_gateway"])
                check_type(argname="argument transit_gateway_route_table_route", value=transit_gateway_route_table_route, expected_type=type_hints["transit_gateway_route_table_route"])
                check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if acl_rule is not None:
                self._values["acl_rule"] = acl_rule
            if additional_details is not None:
                self._values["additional_details"] = additional_details
            if component is not None:
                self._values["component"] = component
            if destination_vpc is not None:
                self._values["destination_vpc"] = destination_vpc
            if elastic_load_balancer_listener is not None:
                self._values["elastic_load_balancer_listener"] = elastic_load_balancer_listener
            if explanations is not None:
                self._values["explanations"] = explanations
            if inbound_header is not None:
                self._values["inbound_header"] = inbound_header
            if outbound_header is not None:
                self._values["outbound_header"] = outbound_header
            if route_table_route is not None:
                self._values["route_table_route"] = route_table_route
            if security_group_rule is not None:
                self._values["security_group_rule"] = security_group_rule
            if sequence_number is not None:
                self._values["sequence_number"] = sequence_number
            if service_name is not None:
                self._values["service_name"] = service_name
            if source_vpc is not None:
                self._values["source_vpc"] = source_vpc
            if subnet is not None:
                self._values["subnet"] = subnet
            if transit_gateway is not None:
                self._values["transit_gateway"] = transit_gateway
            if transit_gateway_route_table_route is not None:
                self._values["transit_gateway_route_table_route"] = transit_gateway_route_table_route
            if vpc is not None:
                self._values["vpc"] = vpc

        @builtins.property
        def acl_rule(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty"]]:
            '''The network ACL rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-aclrule
            '''
            result = self._values.get("acl_rule")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty"]], result)

        @builtins.property
        def additional_details(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AdditionalDetailProperty"]]]]:
            '''The additional details.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-additionaldetails
            '''
            result = self._values.get("additional_details")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AdditionalDetailProperty"]]]], result)

        @builtins.property
        def component(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The component.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-component
            '''
            result = self._values.get("component")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def destination_vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The destination VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-destinationvpc
            '''
            result = self._values.get("destination_vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def elastic_load_balancer_listener(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The load balancer listener.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-elasticloadbalancerlistener
            '''
            result = self._values.get("elastic_load_balancer_listener")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def explanations(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.ExplanationProperty"]]]]:
            '''The explanation codes.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-explanations
            '''
            result = self._values.get("explanations")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.ExplanationProperty"]]]], result)

        @builtins.property
        def inbound_header(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty"]]:
            '''The inbound header.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-inboundheader
            '''
            result = self._values.get("inbound_header")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty"]], result)

        @builtins.property
        def outbound_header(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty"]]:
            '''The outbound header.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-outboundheader
            '''
            result = self._values.get("outbound_header")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty"]], result)

        @builtins.property
        def route_table_route(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty"]]:
            '''The route table route.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-routetableroute
            '''
            result = self._values.get("route_table_route")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty"]], result)

        @builtins.property
        def security_group_rule(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty"]]:
            '''The security group rule.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-securitygrouprule
            '''
            result = self._values.get("security_group_rule")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty"]], result)

        @builtins.property
        def sequence_number(self) -> typing.Optional[jsii.Number]:
            '''The sequence number.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-sequencenumber
            '''
            result = self._values.get("sequence_number")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def service_name(self) -> typing.Optional[builtins.str]:
            '''The name of the VPC endpoint service.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-servicename
            '''
            result = self._values.get("service_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The source VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-sourcevpc
            '''
            result = self._values.get("source_vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def subnet(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The subnet.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-subnet
            '''
            result = self._values.get("subnet")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The transit gateway.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-transitgateway
            '''
            result = self._values.get("transit_gateway")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        @builtins.property
        def transit_gateway_route_table_route(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty"]]:
            '''The route in a transit gateway route table.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-transitgatewayroutetableroute
            '''
            result = self._values.get("transit_gateway_route_table_route")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty"]], result)

        @builtins.property
        def vpc(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]]:
            '''The component VPC.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-pathcomponent.html#cfn-ec2-networkinsightsanalysis-pathcomponent-vpc
            '''
            result = self._values.get("vpc")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsAnalysis.AnalysisComponentProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PathComponentProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.PortRangeProperty",
        jsii_struct_bases=[],
        name_mapping={"from_": "from", "to": "to"},
    )
    class PortRangeProperty:
        def __init__(
            self,
            *,
            from_: typing.Optional[jsii.Number] = None,
            to: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a range of ports.

            :param from_: The first port in the range.
            :param to: The last port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-portrange.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                port_range_property = ec2.CfnNetworkInsightsAnalysis.PortRangeProperty(
                    from=123,
                    to=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__409f0466dcd116c1df92bba15329f6279a2e75d43d1f6456cb6b8d6f50f224c4)
                check_type(argname="argument from_", value=from_, expected_type=type_hints["from_"])
                check_type(argname="argument to", value=to, expected_type=type_hints["to"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if from_ is not None:
                self._values["from_"] = from_
            if to is not None:
                self._values["to"] = to

        @builtins.property
        def from_(self) -> typing.Optional[jsii.Number]:
            '''The first port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-portrange.html#cfn-ec2-networkinsightsanalysis-portrange-from
            '''
            result = self._values.get("from_")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def to(self) -> typing.Optional[jsii.Number]:
            '''The last port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-portrange.html#cfn-ec2-networkinsightsanalysis-portrange-to
            '''
            result = self._values.get("to")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PortRangeProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty",
        jsii_struct_bases=[],
        name_mapping={
            "attachment_id": "attachmentId",
            "destination_cidr": "destinationCidr",
            "prefix_list_id": "prefixListId",
            "resource_id": "resourceId",
            "resource_type": "resourceType",
            "route_origin": "routeOrigin",
            "state": "state",
        },
    )
    class TransitGatewayRouteTableRouteProperty:
        def __init__(
            self,
            *,
            attachment_id: typing.Optional[builtins.str] = None,
            destination_cidr: typing.Optional[builtins.str] = None,
            prefix_list_id: typing.Optional[builtins.str] = None,
            resource_id: typing.Optional[builtins.str] = None,
            resource_type: typing.Optional[builtins.str] = None,
            route_origin: typing.Optional[builtins.str] = None,
            state: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a route in a transit gateway route table.

            :param attachment_id: The ID of the route attachment.
            :param destination_cidr: The CIDR block used for destination matches.
            :param prefix_list_id: The ID of the prefix list.
            :param resource_id: The ID of the resource for the route attachment.
            :param resource_type: The resource type for the route attachment.
            :param route_origin: The route origin. The following are the possible values:. - static - propagated
            :param state: The state of the route.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                transit_gateway_route_table_route_property = ec2.CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty(
                    attachment_id="attachmentId",
                    destination_cidr="destinationCidr",
                    prefix_list_id="prefixListId",
                    resource_id="resourceId",
                    resource_type="resourceType",
                    route_origin="routeOrigin",
                    state="state"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__00d7e3a8e802c3ad59e6e5714eeb743641381b65101c240af6b9f93341e5464f)
                check_type(argname="argument attachment_id", value=attachment_id, expected_type=type_hints["attachment_id"])
                check_type(argname="argument destination_cidr", value=destination_cidr, expected_type=type_hints["destination_cidr"])
                check_type(argname="argument prefix_list_id", value=prefix_list_id, expected_type=type_hints["prefix_list_id"])
                check_type(argname="argument resource_id", value=resource_id, expected_type=type_hints["resource_id"])
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument route_origin", value=route_origin, expected_type=type_hints["route_origin"])
                check_type(argname="argument state", value=state, expected_type=type_hints["state"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if attachment_id is not None:
                self._values["attachment_id"] = attachment_id
            if destination_cidr is not None:
                self._values["destination_cidr"] = destination_cidr
            if prefix_list_id is not None:
                self._values["prefix_list_id"] = prefix_list_id
            if resource_id is not None:
                self._values["resource_id"] = resource_id
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if route_origin is not None:
                self._values["route_origin"] = route_origin
            if state is not None:
                self._values["state"] = state

        @builtins.property
        def attachment_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the route attachment.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-attachmentid
            '''
            result = self._values.get("attachment_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def destination_cidr(self) -> typing.Optional[builtins.str]:
            '''The CIDR block used for destination matches.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-destinationcidr
            '''
            result = self._values.get("destination_cidr")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def prefix_list_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the prefix list.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-prefixlistid
            '''
            result = self._values.get("prefix_list_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def resource_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the resource for the route attachment.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-resourceid
            '''
            result = self._values.get("resource_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The resource type for the route attachment.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def route_origin(self) -> typing.Optional[builtins.str]:
            '''The route origin. The following are the possible values:.

            - static
            - propagated

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-routeorigin
            '''
            result = self._values.get("route_origin")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def state(self) -> typing.Optional[builtins.str]:
            '''The state of the route.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightsanalysis-transitgatewayroutetableroute.html#cfn-ec2-networkinsightsanalysis-transitgatewayroutetableroute-state
            '''
            result = self._values.get("state")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TransitGatewayRouteTableRouteProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsAnalysisProps",
    jsii_struct_bases=[],
    name_mapping={
        "network_insights_path_id": "networkInsightsPathId",
        "additional_accounts": "additionalAccounts",
        "filter_in_arns": "filterInArns",
        "tags": "tags",
    },
)
class CfnNetworkInsightsAnalysisProps:
    def __init__(
        self,
        *,
        network_insights_path_id: builtins.str,
        additional_accounts: typing.Optional[typing.Sequence[builtins.str]] = None,
        filter_in_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInsightsAnalysis``.

        :param network_insights_path_id: The ID of the path.
        :param additional_accounts: The member accounts that contain resources that the path can traverse.
        :param filter_in_arns: The Amazon Resource Names (ARN) of the resources that the path must traverse.
        :param tags: The tags to apply.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_insights_analysis_props = ec2.CfnNetworkInsightsAnalysisProps(
                network_insights_path_id="networkInsightsPathId",
            
                # the properties below are optional
                additional_accounts=["additionalAccounts"],
                filter_in_arns=["filterInArns"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a33d492e092024ce4f03ae533f82763ceee950f76808ddc3b6329ed54b1a7731)
            check_type(argname="argument network_insights_path_id", value=network_insights_path_id, expected_type=type_hints["network_insights_path_id"])
            check_type(argname="argument additional_accounts", value=additional_accounts, expected_type=type_hints["additional_accounts"])
            check_type(argname="argument filter_in_arns", value=filter_in_arns, expected_type=type_hints["filter_in_arns"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_insights_path_id": network_insights_path_id,
        }
        if additional_accounts is not None:
            self._values["additional_accounts"] = additional_accounts
        if filter_in_arns is not None:
            self._values["filter_in_arns"] = filter_in_arns
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def network_insights_path_id(self) -> builtins.str:
        '''The ID of the path.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html#cfn-ec2-networkinsightsanalysis-networkinsightspathid
        '''
        result = self._values.get("network_insights_path_id")
        assert result is not None, "Required property 'network_insights_path_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def additional_accounts(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The member accounts that contain resources that the path can traverse.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html#cfn-ec2-networkinsightsanalysis-additionalaccounts
        '''
        result = self._values.get("additional_accounts")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def filter_in_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARN) of the resources that the path must traverse.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html#cfn-ec2-networkinsightsanalysis-filterinarns
        '''
        result = self._values.get("filter_in_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightsanalysis.html#cfn-ec2-networkinsightsanalysis-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInsightsAnalysisProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkInsightsPath(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsPath",
):
    '''Specifies a path to analyze for reachability.

    VPC Reachability Analyzer enables you to analyze and debug network reachability between two resources in your virtual private cloud (VPC). For more information, see the `Reachability Analyzer User Guide <https://docs.aws.amazon.com/vpc/latest/reachability/what-is-reachability-analyzer.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html
    :cloudformationResource: AWS::EC2::NetworkInsightsPath
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_insights_path = ec2.CfnNetworkInsightsPath(self, "MyCfnNetworkInsightsPath",
            protocol="protocol",
            source="source",
        
            # the properties below are optional
            destination="destination",
            destination_ip="destinationIp",
            destination_port=123,
            filter_at_destination=ec2.CfnNetworkInsightsPath.PathFilterProperty(
                destination_address="destinationAddress",
                destination_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                    from_port=123,
                    to_port=123
                ),
                source_address="sourceAddress",
                source_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                    from_port=123,
                    to_port=123
                )
            ),
            filter_at_source=ec2.CfnNetworkInsightsPath.PathFilterProperty(
                destination_address="destinationAddress",
                destination_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                    from_port=123,
                    to_port=123
                ),
                source_address="sourceAddress",
                source_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                    from_port=123,
                    to_port=123
                )
            ),
            source_ip="sourceIp",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        protocol: builtins.str,
        source: builtins.str,
        destination: typing.Optional[builtins.str] = None,
        destination_ip: typing.Optional[builtins.str] = None,
        destination_port: typing.Optional[jsii.Number] = None,
        filter_at_destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsPath.PathFilterProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        filter_at_source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsPath.PathFilterProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        source_ip: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param protocol: The protocol.
        :param source: The ID or ARN of the source. If the resource is in another account, you must specify an ARN.
        :param destination: The ID or ARN of the destination. If the resource is in another account, you must specify an ARN.
        :param destination_ip: The IP address of the destination.
        :param destination_port: The destination port.
        :param filter_at_destination: Scopes the analysis to network paths that match specific filters at the destination. If you specify this parameter, you can't specify the parameter for the destination IP address.
        :param filter_at_source: Scopes the analysis to network paths that match specific filters at the source. If you specify this parameter, you can't specify the parameters for the source IP address or the destination port.
        :param source_ip: The IP address of the source.
        :param tags: The tags to add to the path.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f7fe7e248a834a6efe9954bca662d634bc784a1945ef06a82f8e180a1b786569)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInsightsPathProps(
            protocol=protocol,
            source=source,
            destination=destination,
            destination_ip=destination_ip,
            destination_port=destination_port,
            filter_at_destination=filter_at_destination,
            filter_at_source=filter_at_source,
            source_ip=source_ip,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__727c2e90bd02c8a49ccd06e5693994d060b2fb6dd8d39545ee9042b07e48c943)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cccc4e27f3a85bf70ba5c68ae3e76300babfd87cf4de27582cdeae7be744e0c)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreatedDate")
    def attr_created_date(self) -> builtins.str:
        '''The time stamp when the path was created.

        :cloudformationAttribute: CreatedDate
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreatedDate"))

    @builtins.property
    @jsii.member(jsii_name="attrDestinationArn")
    def attr_destination_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the destination.

        :cloudformationAttribute: DestinationArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDestinationArn"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsPathArn")
    def attr_network_insights_path_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the path.

        :cloudformationAttribute: NetworkInsightsPathArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsPathArn"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInsightsPathId")
    def attr_network_insights_path_id(self) -> builtins.str:
        '''The ID of the path.

        :cloudformationAttribute: NetworkInsightsPathId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkInsightsPathId"))

    @builtins.property
    @jsii.member(jsii_name="attrSourceArn")
    def attr_source_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the source.

        :cloudformationAttribute: SourceArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSourceArn"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="protocol")
    def protocol(self) -> builtins.str:
        '''The protocol.'''
        return typing.cast(builtins.str, jsii.get(self, "protocol"))

    @protocol.setter
    def protocol(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e1a79262a8e5afad332c30acb77a35cb1268b2ae8173926fec6c86d65d45a8ef)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "protocol", value)

    @builtins.property
    @jsii.member(jsii_name="source")
    def source(self) -> builtins.str:
        '''The ID or ARN of the source.'''
        return typing.cast(builtins.str, jsii.get(self, "source"))

    @source.setter
    def source(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a689147656a18301a3ae4415c5486f925e8fda67c8bab29c04b90161386bb930)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "source", value)

    @builtins.property
    @jsii.member(jsii_name="destination")
    def destination(self) -> typing.Optional[builtins.str]:
        '''The ID or ARN of the destination.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destination"))

    @destination.setter
    def destination(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__df96fe03f2b38a35b14ce16c9edf72487a38c9e53522a2844abae3f05d05a74d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destination", value)

    @builtins.property
    @jsii.member(jsii_name="destinationIp")
    def destination_ip(self) -> typing.Optional[builtins.str]:
        '''The IP address of the destination.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationIp"))

    @destination_ip.setter
    def destination_ip(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf89bbca436bc848953f41e635653aa1d55915d7e8fd29c6e7e2674bc683c7b2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationIp", value)

    @builtins.property
    @jsii.member(jsii_name="destinationPort")
    def destination_port(self) -> typing.Optional[jsii.Number]:
        '''The destination port.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "destinationPort"))

    @destination_port.setter
    def destination_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__273be4117afb24e4f9c1919e2eb7009d1427f7300ea7e3e4aabd339109710388)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationPort", value)

    @builtins.property
    @jsii.member(jsii_name="filterAtDestination")
    def filter_at_destination(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]]:
        '''Scopes the analysis to network paths that match specific filters at the destination.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]], jsii.get(self, "filterAtDestination"))

    @filter_at_destination.setter
    def filter_at_destination(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7de97fb08b3979783843344622441f0aba608fb5bdd1d75d9d83dea45b1138b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "filterAtDestination", value)

    @builtins.property
    @jsii.member(jsii_name="filterAtSource")
    def filter_at_source(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]]:
        '''Scopes the analysis to network paths that match specific filters at the source.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]], jsii.get(self, "filterAtSource"))

    @filter_at_source.setter
    def filter_at_source(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.PathFilterProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29bb049b177504b26d9314549066eab8e02aa2539e21e83ddc4cddaafbeddc76)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "filterAtSource", value)

    @builtins.property
    @jsii.member(jsii_name="sourceIp")
    def source_ip(self) -> typing.Optional[builtins.str]:
        '''The IP address of the source.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourceIp"))

    @source_ip.setter
    def source_ip(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25b7233d52c3940a670ba0d354408632b91d33abdea67df95c45adfd38a19ed7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceIp", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to add to the path.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e631c64467884caee4a0ceb81a0fe348d1dbe4d4fbd6fdbcbf507bcd3be96e1e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsPath.FilterPortRangeProperty",
        jsii_struct_bases=[],
        name_mapping={"from_port": "fromPort", "to_port": "toPort"},
    )
    class FilterPortRangeProperty:
        def __init__(
            self,
            *,
            from_port: typing.Optional[jsii.Number] = None,
            to_port: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Describes a port range.

            :param from_port: The first port in the range.
            :param to_port: The last port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-filterportrange.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                filter_port_range_property = ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                    from_port=123,
                    to_port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__5b6b14caf6e6967872e22c2813155f115beea081480b6a0e59aa8805ea09ba72)
                check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
                check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if from_port is not None:
                self._values["from_port"] = from_port
            if to_port is not None:
                self._values["to_port"] = to_port

        @builtins.property
        def from_port(self) -> typing.Optional[jsii.Number]:
            '''The first port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-filterportrange.html#cfn-ec2-networkinsightspath-filterportrange-fromport
            '''
            result = self._values.get("from_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def to_port(self) -> typing.Optional[jsii.Number]:
            '''The last port in the range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-filterportrange.html#cfn-ec2-networkinsightspath-filterportrange-toport
            '''
            result = self._values.get("to_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FilterPortRangeProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsPath.PathFilterProperty",
        jsii_struct_bases=[],
        name_mapping={
            "destination_address": "destinationAddress",
            "destination_port_range": "destinationPortRange",
            "source_address": "sourceAddress",
            "source_port_range": "sourcePortRange",
        },
    )
    class PathFilterProperty:
        def __init__(
            self,
            *,
            destination_address: typing.Optional[builtins.str] = None,
            destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsPath.FilterPortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            source_address: typing.Optional[builtins.str] = None,
            source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInsightsPath.FilterPortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes a set of filters for a path analysis.

            Use path filters to scope the analysis when there can be multiple resulting paths.

            :param destination_address: The destination IPv4 address.
            :param destination_port_range: The destination port range.
            :param source_address: The source IPv4 address.
            :param source_port_range: The source port range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-pathfilter.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                path_filter_property = ec2.CfnNetworkInsightsPath.PathFilterProperty(
                    destination_address="destinationAddress",
                    destination_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    ),
                    source_address="sourceAddress",
                    source_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__faad4550eaf1b07ce0dee675d9dc5aaffde167e22cc470d3f29dd8c2e4b4b3be)
                check_type(argname="argument destination_address", value=destination_address, expected_type=type_hints["destination_address"])
                check_type(argname="argument destination_port_range", value=destination_port_range, expected_type=type_hints["destination_port_range"])
                check_type(argname="argument source_address", value=source_address, expected_type=type_hints["source_address"])
                check_type(argname="argument source_port_range", value=source_port_range, expected_type=type_hints["source_port_range"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if destination_address is not None:
                self._values["destination_address"] = destination_address
            if destination_port_range is not None:
                self._values["destination_port_range"] = destination_port_range
            if source_address is not None:
                self._values["source_address"] = source_address
            if source_port_range is not None:
                self._values["source_port_range"] = source_port_range

        @builtins.property
        def destination_address(self) -> typing.Optional[builtins.str]:
            '''The destination IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-pathfilter.html#cfn-ec2-networkinsightspath-pathfilter-destinationaddress
            '''
            result = self._values.get("destination_address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def destination_port_range(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.FilterPortRangeProperty"]]:
            '''The destination port range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-pathfilter.html#cfn-ec2-networkinsightspath-pathfilter-destinationportrange
            '''
            result = self._values.get("destination_port_range")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.FilterPortRangeProperty"]], result)

        @builtins.property
        def source_address(self) -> typing.Optional[builtins.str]:
            '''The source IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-pathfilter.html#cfn-ec2-networkinsightspath-pathfilter-sourceaddress
            '''
            result = self._values.get("source_address")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_port_range(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.FilterPortRangeProperty"]]:
            '''The source port range.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinsightspath-pathfilter.html#cfn-ec2-networkinsightspath-pathfilter-sourceportrange
            '''
            result = self._values.get("source_port_range")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInsightsPath.FilterPortRangeProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PathFilterProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInsightsPathProps",
    jsii_struct_bases=[],
    name_mapping={
        "protocol": "protocol",
        "source": "source",
        "destination": "destination",
        "destination_ip": "destinationIp",
        "destination_port": "destinationPort",
        "filter_at_destination": "filterAtDestination",
        "filter_at_source": "filterAtSource",
        "source_ip": "sourceIp",
        "tags": "tags",
    },
)
class CfnNetworkInsightsPathProps:
    def __init__(
        self,
        *,
        protocol: builtins.str,
        source: builtins.str,
        destination: typing.Optional[builtins.str] = None,
        destination_ip: typing.Optional[builtins.str] = None,
        destination_port: typing.Optional[jsii.Number] = None,
        filter_at_destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        filter_at_source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        source_ip: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInsightsPath``.

        :param protocol: The protocol.
        :param source: The ID or ARN of the source. If the resource is in another account, you must specify an ARN.
        :param destination: The ID or ARN of the destination. If the resource is in another account, you must specify an ARN.
        :param destination_ip: The IP address of the destination.
        :param destination_port: The destination port.
        :param filter_at_destination: Scopes the analysis to network paths that match specific filters at the destination. If you specify this parameter, you can't specify the parameter for the destination IP address.
        :param filter_at_source: Scopes the analysis to network paths that match specific filters at the source. If you specify this parameter, you can't specify the parameters for the source IP address or the destination port.
        :param source_ip: The IP address of the source.
        :param tags: The tags to add to the path.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_insights_path_props = ec2.CfnNetworkInsightsPathProps(
                protocol="protocol",
                source="source",
            
                # the properties below are optional
                destination="destination",
                destination_ip="destinationIp",
                destination_port=123,
                filter_at_destination=ec2.CfnNetworkInsightsPath.PathFilterProperty(
                    destination_address="destinationAddress",
                    destination_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    ),
                    source_address="sourceAddress",
                    source_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    )
                ),
                filter_at_source=ec2.CfnNetworkInsightsPath.PathFilterProperty(
                    destination_address="destinationAddress",
                    destination_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    ),
                    source_address="sourceAddress",
                    source_port_range=ec2.CfnNetworkInsightsPath.FilterPortRangeProperty(
                        from_port=123,
                        to_port=123
                    )
                ),
                source_ip="sourceIp",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f101d0a990ddf3dab968e411a0437d6e2154bb00c3ff7ef35d0afa814c09c74a)
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
            check_type(argname="argument destination_ip", value=destination_ip, expected_type=type_hints["destination_ip"])
            check_type(argname="argument destination_port", value=destination_port, expected_type=type_hints["destination_port"])
            check_type(argname="argument filter_at_destination", value=filter_at_destination, expected_type=type_hints["filter_at_destination"])
            check_type(argname="argument filter_at_source", value=filter_at_source, expected_type=type_hints["filter_at_source"])
            check_type(argname="argument source_ip", value=source_ip, expected_type=type_hints["source_ip"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "protocol": protocol,
            "source": source,
        }
        if destination is not None:
            self._values["destination"] = destination
        if destination_ip is not None:
            self._values["destination_ip"] = destination_ip
        if destination_port is not None:
            self._values["destination_port"] = destination_port
        if filter_at_destination is not None:
            self._values["filter_at_destination"] = filter_at_destination
        if filter_at_source is not None:
            self._values["filter_at_source"] = filter_at_source
        if source_ip is not None:
            self._values["source_ip"] = source_ip
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def protocol(self) -> builtins.str:
        '''The protocol.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-protocol
        '''
        result = self._values.get("protocol")
        assert result is not None, "Required property 'protocol' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def source(self) -> builtins.str:
        '''The ID or ARN of the source.

        If the resource is in another account, you must specify an ARN.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-source
        '''
        result = self._values.get("source")
        assert result is not None, "Required property 'source' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def destination(self) -> typing.Optional[builtins.str]:
        '''The ID or ARN of the destination.

        If the resource is in another account, you must specify an ARN.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-destination
        '''
        result = self._values.get("destination")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_ip(self) -> typing.Optional[builtins.str]:
        '''The IP address of the destination.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-destinationip
        '''
        result = self._values.get("destination_ip")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_port(self) -> typing.Optional[jsii.Number]:
        '''The destination port.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-destinationport
        '''
        result = self._values.get("destination_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def filter_at_destination(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]]:
        '''Scopes the analysis to network paths that match specific filters at the destination.

        If you specify this parameter, you can't specify the parameter for the destination IP address.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-filteratdestination
        '''
        result = self._values.get("filter_at_destination")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]], result)

    @builtins.property
    def filter_at_source(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]]:
        '''Scopes the analysis to network paths that match specific filters at the source.

        If you specify this parameter, you can't specify the parameters for the source IP address or the destination port.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-filteratsource
        '''
        result = self._values.get("filter_at_source")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]], result)

    @builtins.property
    def source_ip(self) -> typing.Optional[builtins.str]:
        '''The IP address of the source.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-sourceip
        '''
        result = self._values.get("source_ip")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to add to the path.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinsightspath.html#cfn-ec2-networkinsightspath-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInsightsPathProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnNetworkInterface(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface",
):
    '''Describes a network interface in an Amazon EC2 instance for AWS CloudFormation .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html
    :cloudformationResource: AWS::EC2::NetworkInterface
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_interface = ec2.CfnNetworkInterface(self, "MyCfnNetworkInterface",
            subnet_id="subnetId",
        
            # the properties below are optional
            connection_tracking_specification=ec2.CfnNetworkInterface.ConnectionTrackingSpecificationProperty(
                tcp_established_timeout=123,
                udp_stream_timeout=123,
                udp_timeout=123
            ),
            description="description",
            enable_primary_ipv6=False,
            group_set=["groupSet"],
            interface_type="interfaceType",
            ipv4_prefix_count=123,
            ipv4_prefixes=[ec2.CfnNetworkInterface.Ipv4PrefixSpecificationProperty(
                ipv4_prefix="ipv4Prefix"
            )],
            ipv6_address_count=123,
            ipv6_addresses=[ec2.CfnNetworkInterface.InstanceIpv6AddressProperty(
                ipv6_address="ipv6Address"
            )],
            ipv6_prefix_count=123,
            ipv6_prefixes=[ec2.CfnNetworkInterface.Ipv6PrefixSpecificationProperty(
                ipv6_prefix="ipv6Prefix"
            )],
            private_ip_address="privateIpAddress",
            private_ip_addresses=[ec2.CfnNetworkInterface.PrivateIpAddressSpecificationProperty(
                primary=False,
                private_ip_address="privateIpAddress"
            )],
            secondary_private_ip_address_count=123,
            source_dest_check=False,
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInterface.ConnectionTrackingSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        enable_primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
        interface_type: typing.Optional[builtins.str] = None,
        ipv4_prefix_count: typing.Optional[jsii.Number] = None,
        ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInterface.Ipv4PrefixSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ipv6_address_count: typing.Optional[jsii.Number] = None,
        ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInterface.InstanceIpv6AddressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ipv6_prefix_count: typing.Optional[jsii.Number] = None,
        ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInterface.Ipv6PrefixSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnNetworkInterface.PrivateIpAddressSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
        source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_id: The ID of the subnet to associate with the network interface.
        :param connection_tracking_specification: A connection tracking specification for the network interface.
        :param description: A description for the network interface.
        :param enable_primary_ipv6: 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.
        :param group_set: The security group IDs associated with this network interface.
        :param interface_type: The type of network interface. The default is ``interface`` . The supported values are ``efa`` and ``trunk`` .
        :param ipv4_prefix_count: 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.
        :param ipv4_prefixes: 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.
        :param ipv6_address_count: The number of IPv6 addresses to assign to a 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.
        :param ipv6_addresses: One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet to associate with 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.
        :param ipv6_prefix_count: 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.
        :param ipv6_prefixes: 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.
        :param private_ip_address: Assigns a single private IP address to the network interface, which is used as the primary private IP address. If you want to specify multiple private IP address, use the ``PrivateIpAddresses`` property.
        :param private_ip_addresses: Assigns private IP addresses 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.
        :param secondary_private_ip_address_count: 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.
        :param source_dest_check: 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.
        :param tags: An arbitrary set of tags (key-value pairs) for this network interface.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8393da3cca9727d94c340192bc7d8b11bde1fb62e8d43771091b9a3e120a301a)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInterfaceProps(
            subnet_id=subnet_id,
            connection_tracking_specification=connection_tracking_specification,
            description=description,
            enable_primary_ipv6=enable_primary_ipv6,
            group_set=group_set,
            interface_type=interface_type,
            ipv4_prefix_count=ipv4_prefix_count,
            ipv4_prefixes=ipv4_prefixes,
            ipv6_address_count=ipv6_address_count,
            ipv6_addresses=ipv6_addresses,
            ipv6_prefix_count=ipv6_prefix_count,
            ipv6_prefixes=ipv6_prefixes,
            private_ip_address=private_ip_address,
            private_ip_addresses=private_ip_addresses,
            secondary_private_ip_address_count=secondary_private_ip_address_count,
            source_dest_check=source_dest_check,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36528adc5439ee87edbb54d96f163e3f07cf28679f7d2c3a64683cc2f634c13d)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3c1cd8b47c372cc1a6fe2ad744be04181d2deb2f86b9056ec1dc305c8f30bde)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the network interface.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrPrimaryIpv6Address")
    def attr_primary_ipv6_address(self) -> builtins.str:
        '''The primary IPv6 address of the network interface.

        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.

        :cloudformationAttribute: PrimaryIpv6Address
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrimaryIpv6Address"))

    @builtins.property
    @jsii.member(jsii_name="attrPrimaryPrivateIpAddress")
    def attr_primary_private_ip_address(self) -> builtins.str:
        '''The primary private IP address of the network interface.

        For example, ``10.0.0.192`` .

        :cloudformationAttribute: PrimaryPrivateIpAddress
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrimaryPrivateIpAddress"))

    @builtins.property
    @jsii.member(jsii_name="attrSecondaryPrivateIpAddresses")
    def attr_secondary_private_ip_addresses(self) -> typing.List[builtins.str]:
        '''The secondary private IP addresses of the network interface.

        For example, ``["10.0.0.161", "10.0.0.162", "10.0.0.163"]`` .

        :cloudformationAttribute: SecondaryPrivateIpAddresses
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrSecondaryPrivateIpAddresses"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet to associate with the network interface.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d46166d55def79a5e6b84dab29e5f6750535d12b7cd3dd8f7b7fbca8177d2bd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="connectionTrackingSpecification")
    def connection_tracking_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.ConnectionTrackingSpecificationProperty"]]:
        '''A connection tracking specification for the network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.ConnectionTrackingSpecificationProperty"]], jsii.get(self, "connectionTrackingSpecification"))

    @connection_tracking_specification.setter
    def connection_tracking_specification(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.ConnectionTrackingSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__326e9b0264afc77aa0c36f83fe4fc0c5c45684eb1bef0b84c090fe6a73606fd8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connectionTrackingSpecification", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the network interface.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b42a1901ff08c6187aea659b7ab30af39da037df52862dd2fb4661cff86a650a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="enablePrimaryIpv6")
    def enable_primary_ipv6(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''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.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "enablePrimaryIpv6"))

    @enable_primary_ipv6.setter
    def enable_primary_ipv6(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b856c33b68d0ad4d8f64d7064b6551f3a20f184bd0bde1d2697f8f87ff0f02cc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enablePrimaryIpv6", value)

    @builtins.property
    @jsii.member(jsii_name="groupSet")
    def group_set(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The security group IDs associated with this network interface.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "groupSet"))

    @group_set.setter
    def group_set(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__33961d8033f73df9d276a5f4d152a5e51803192bd216c4c1de476cdb04ef1165)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupSet", value)

    @builtins.property
    @jsii.member(jsii_name="interfaceType")
    def interface_type(self) -> typing.Optional[builtins.str]:
        '''The type of network interface.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "interfaceType"))

    @interface_type.setter
    def interface_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__06ca573668106730ff2f3a78bb55507676f54e57996a31ccaea4840dac9f4452)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "interfaceType", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4PrefixCount")
    def ipv4_prefix_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv4 prefixes to be automatically assigned to the network interface.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv4PrefixCount"))

    @ipv4_prefix_count.setter
    def ipv4_prefix_count(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e371f5bed19ead07cff146cd07611a39380c23e9712dfd72904565ca8f9a7bb0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4PrefixCount", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4Prefixes")
    def ipv4_prefixes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv4PrefixSpecificationProperty"]]]]:
        '''The IPv4 delegated prefixes that are assigned to the network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv4PrefixSpecificationProperty"]]]], jsii.get(self, "ipv4Prefixes"))

    @ipv4_prefixes.setter
    def ipv4_prefixes(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv4PrefixSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd643933b52f02097d39ab45f65c2e07f4f6e1a74aa7d9d10ddda902b793faec)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4Prefixes", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6AddressCount")
    def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv6 addresses to assign to a network interface.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6AddressCount"))

    @ipv6_address_count.setter
    def ipv6_address_count(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e27163d6b64f17a9cee7c8cd34a6efb53a01d0f3826e972e894c6f8d6146d3a2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6AddressCount", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6Addresses")
    def ipv6_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.InstanceIpv6AddressProperty"]]]]:
        '''One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet to associate with the network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.InstanceIpv6AddressProperty"]]]], jsii.get(self, "ipv6Addresses"))

    @ipv6_addresses.setter
    def ipv6_addresses(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.InstanceIpv6AddressProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec2f431d0253f1425093379bbed39269acef6002d9a6a6937578e7542e26a30b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6Addresses", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6PrefixCount")
    def ipv6_prefix_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv6 prefixes to be automatically assigned to the network interface.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6PrefixCount"))

    @ipv6_prefix_count.setter
    def ipv6_prefix_count(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__afcdb033156daa389c5aec6a9129fc785ec6caca4c5d07dd806d875e836cf591)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6PrefixCount", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6Prefixes")
    def ipv6_prefixes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv6PrefixSpecificationProperty"]]]]:
        '''The IPv6 delegated prefixes that are assigned to the network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv6PrefixSpecificationProperty"]]]], jsii.get(self, "ipv6Prefixes"))

    @ipv6_prefixes.setter
    def ipv6_prefixes(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.Ipv6PrefixSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36c065ce0b45ef97c2ba76327e28b0a2f20d775d10bf7f29368ae2928519a859)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6Prefixes", value)

    @builtins.property
    @jsii.member(jsii_name="privateIpAddress")
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''Assigns a single private IP address to the network interface, which is used as the primary private IP address.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "privateIpAddress"))

    @private_ip_address.setter
    def private_ip_address(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12f6d832e68daf5d32cdaf3fbef11f9b066f61e755598181f9d4e11cf1142216)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateIpAddress", value)

    @builtins.property
    @jsii.member(jsii_name="privateIpAddresses")
    def private_ip_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.PrivateIpAddressSpecificationProperty"]]]]:
        '''Assigns private IP addresses to the network interface.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.PrivateIpAddressSpecificationProperty"]]]], jsii.get(self, "privateIpAddresses"))

    @private_ip_addresses.setter
    def private_ip_addresses(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnNetworkInterface.PrivateIpAddressSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9abc518674008194abac9a771b948d64ee80e214cb425ae037f288639dc89da5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateIpAddresses", value)

    @builtins.property
    @jsii.member(jsii_name="secondaryPrivateIpAddressCount")
    def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
        '''The number of secondary private IPv4 addresses to assign to a network interface.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "secondaryPrivateIpAddressCount"))

    @secondary_private_ip_address_count.setter
    def secondary_private_ip_address_count(
        self,
        value: typing.Optional[jsii.Number],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1425a70b1facffb8491c8d7d3f99bb7924e01c01241fb60d1c11c2772ff715b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "secondaryPrivateIpAddressCount", value)

    @builtins.property
    @jsii.member(jsii_name="sourceDestCheck")
    def source_dest_check(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Enable or disable source/destination checks, which ensure that the instance is either the source or the destination of any traffic that it receives.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "sourceDestCheck"))

    @source_dest_check.setter
    def source_dest_check(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f221feb4b623eefef062abdc5ace0a54c176344126862c4806c435da7f3a4697)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceDestCheck", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''An arbitrary set of tags (key-value pairs) for this network interface.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdd53da68121c116130e4262ff68795dc8631f701d848bd6519c93813c05583b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface.ConnectionTrackingSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "tcp_established_timeout": "tcpEstablishedTimeout",
            "udp_stream_timeout": "udpStreamTimeout",
            "udp_timeout": "udpTimeout",
        },
    )
    class ConnectionTrackingSpecificationProperty:
        def __init__(
            self,
            *,
            tcp_established_timeout: typing.Optional[jsii.Number] = None,
            udp_stream_timeout: typing.Optional[jsii.Number] = None,
            udp_timeout: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''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* .

            :param tcp_established_timeout: 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.
            :param udp_stream_timeout: 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.
            :param udp_timeout: 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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-connectiontrackingspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                connection_tracking_specification_property = ec2.CfnNetworkInterface.ConnectionTrackingSpecificationProperty(
                    tcp_established_timeout=123,
                    udp_stream_timeout=123,
                    udp_timeout=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__37da425035e16a13c422186f0f8aed1970a49f480858e8ee93f7ad6e18e563c4)
                check_type(argname="argument tcp_established_timeout", value=tcp_established_timeout, expected_type=type_hints["tcp_established_timeout"])
                check_type(argname="argument udp_stream_timeout", value=udp_stream_timeout, expected_type=type_hints["udp_stream_timeout"])
                check_type(argname="argument udp_timeout", value=udp_timeout, expected_type=type_hints["udp_timeout"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if tcp_established_timeout is not None:
                self._values["tcp_established_timeout"] = tcp_established_timeout
            if udp_stream_timeout is not None:
                self._values["udp_stream_timeout"] = udp_stream_timeout
            if udp_timeout is not None:
                self._values["udp_timeout"] = udp_timeout

        @builtins.property
        def tcp_established_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-connectiontrackingspecification.html#cfn-ec2-networkinterface-connectiontrackingspecification-tcpestablishedtimeout
            '''
            result = self._values.get("tcp_established_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def udp_stream_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-connectiontrackingspecification.html#cfn-ec2-networkinterface-connectiontrackingspecification-udpstreamtimeout
            '''
            result = self._values.get("udp_stream_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def udp_timeout(self) -> typing.Optional[jsii.Number]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-connectiontrackingspecification.html#cfn-ec2-networkinterface-connectiontrackingspecification-udptimeout
            '''
            result = self._values.get("udp_timeout")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ConnectionTrackingSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface.InstanceIpv6AddressProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_address": "ipv6Address"},
    )
    class InstanceIpv6AddressProperty:
        def __init__(self, *, ipv6_address: builtins.str) -> None:
            '''Describes the IPv6 addresses to associate with the network interface.

            :param ipv6_address: An IPv6 address to associate with the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-instanceipv6address.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_ipv6_address_property = ec2.CfnNetworkInterface.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__52bfc9d4c4cc10dfcfa5ca2b158de5da7d500b8cdd062f141f3a855f70a6e1f0)
                check_type(argname="argument ipv6_address", value=ipv6_address, expected_type=type_hints["ipv6_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ipv6_address": ipv6_address,
            }

        @builtins.property
        def ipv6_address(self) -> builtins.str:
            '''An IPv6 address to associate with the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-instanceipv6address.html#cfn-ec2-networkinterface-instanceipv6address-ipv6address
            '''
            result = self._values.get("ipv6_address")
            assert result is not None, "Required property 'ipv6_address' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceIpv6AddressProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface.Ipv4PrefixSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv4_prefix": "ipv4Prefix"},
    )
    class Ipv4PrefixSpecificationProperty:
        def __init__(self, *, ipv4_prefix: builtins.str) -> None:
            '''Describes an IPv4 prefix.

            :param ipv4_prefix: The IPv4 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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-ipv4prefixspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipv4_prefix_specification_property = ec2.CfnNetworkInterface.Ipv4PrefixSpecificationProperty(
                    ipv4_prefix="ipv4Prefix"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__38380f5705d10d112c9c88463594b275fd3742077a27edd72850daee8c83b3d3)
                check_type(argname="argument ipv4_prefix", value=ipv4_prefix, expected_type=type_hints["ipv4_prefix"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ipv4_prefix": ipv4_prefix,
            }

        @builtins.property
        def ipv4_prefix(self) -> builtins.str:
            '''The IPv4 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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-ipv4prefixspecification.html#cfn-ec2-networkinterface-ipv4prefixspecification-ipv4prefix
            '''
            result = self._values.get("ipv4_prefix")
            assert result is not None, "Required property 'ipv4_prefix' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "Ipv4PrefixSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface.Ipv6PrefixSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_prefix": "ipv6Prefix"},
    )
    class Ipv6PrefixSpecificationProperty:
        def __init__(self, *, ipv6_prefix: builtins.str) -> None:
            '''Describes the IPv6 prefix.

            :param ipv6_prefix: 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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-ipv6prefixspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ipv6_prefix_specification_property = ec2.CfnNetworkInterface.Ipv6PrefixSpecificationProperty(
                    ipv6_prefix="ipv6Prefix"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__dd87b859450e8afeee0ab152a487983d6896c50bbdc2238c51903c507f7e6fcd)
                check_type(argname="argument ipv6_prefix", value=ipv6_prefix, expected_type=type_hints["ipv6_prefix"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ipv6_prefix": ipv6_prefix,
            }

        @builtins.property
        def ipv6_prefix(self) -> builtins.str:
            '''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* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-ipv6prefixspecification.html#cfn-ec2-networkinterface-ipv6prefixspecification-ipv6prefix
            '''
            result = self._values.get("ipv6_prefix")
            assert result is not None, "Required property 'ipv6_prefix' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "Ipv6PrefixSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterface.PrivateIpAddressSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"primary": "primary", "private_ip_address": "privateIpAddress"},
    )
    class PrivateIpAddressSpecificationProperty:
        def __init__(
            self,
            *,
            primary: typing.Union[builtins.bool, _IResolvable_da3f097b],
            private_ip_address: builtins.str,
        ) -> None:
            '''Describes a secondary private IPv4 address for a network interface.

            :param primary: 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.
            :param private_ip_address: The private IP address of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-privateipaddressspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_ip_address_specification_property = ec2.CfnNetworkInterface.PrivateIpAddressSpecificationProperty(
                    primary=False,
                    private_ip_address="privateIpAddress"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d2da2a4621e14b60dbae723cd0270f439aa232756c238ce733bfdc043ab3defd)
                check_type(argname="argument primary", value=primary, expected_type=type_hints["primary"])
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "primary": primary,
                "private_ip_address": private_ip_address,
            }

        @builtins.property
        def primary(self) -> typing.Union[builtins.bool, _IResolvable_da3f097b]:
            '''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.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-privateipaddressspecification.html#cfn-ec2-networkinterface-privateipaddressspecification-primary
            '''
            result = self._values.get("primary")
            assert result is not None, "Required property 'primary' is missing"
            return typing.cast(typing.Union[builtins.bool, _IResolvable_da3f097b], result)

        @builtins.property
        def private_ip_address(self) -> builtins.str:
            '''The private IP address of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-networkinterface-privateipaddressspecification.html#cfn-ec2-networkinterface-privateipaddressspecification-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            assert result is not None, "Required property 'private_ip_address' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateIpAddressSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnNetworkInterfaceAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterfaceAttachment",
):
    '''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.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html
    :cloudformationResource: AWS::EC2::NetworkInterfaceAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_interface_attachment = ec2.CfnNetworkInterfaceAttachment(self, "MyCfnNetworkInterfaceAttachment",
            device_index="deviceIndex",
            instance_id="instanceId",
            network_interface_id="networkInterfaceId",
        
            # the properties below are optional
            delete_on_termination=False
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        device_index: builtins.str,
        instance_id: builtins.str,
        network_interface_id: builtins.str,
        delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param device_index: The network interface's position in the attachment order. For example, the first attached network interface has a ``DeviceIndex`` of 0.
        :param instance_id: The ID of the instance to which you will attach the ENI.
        :param network_interface_id: The ID of the ENI that you want to attach.
        :param delete_on_termination: Whether to delete the network interface when the instance terminates. By default, this value is set to ``true`` . Default: - true
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3bd398f8321bdc7fbfd14c84bf37b253e1282ce256683087217df8bdb9917aa6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInterfaceAttachmentProps(
            device_index=device_index,
            instance_id=instance_id,
            network_interface_id=network_interface_id,
            delete_on_termination=delete_on_termination,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__554cd7341909721afe1ab2997e383a1d6a07869eba1d1d0fc42e2066bb43895d)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02eddcddc4e9a3e34cc764cc9ae14a1b05b7402c6a41e0c8b4527af6823d5fad)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAttachmentId")
    def attr_attachment_id(self) -> builtins.str:
        '''The ID of the network interface attachment.

        :cloudformationAttribute: AttachmentId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAttachmentId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="deviceIndex")
    def device_index(self) -> builtins.str:
        '''The network interface's position in the attachment order.'''
        return typing.cast(builtins.str, jsii.get(self, "deviceIndex"))

    @device_index.setter
    def device_index(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cad57983c8bfca5f6e07a872722208c9bc1ba7507816b15b90198d0009a51999)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deviceIndex", value)

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The ID of the instance to which you will attach the ENI.'''
        return typing.cast(builtins.str, jsii.get(self, "instanceId"))

    @instance_id.setter
    def instance_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d163bbe0d4a2b99d7ea2fdc44ad45b5c52fb1b4af5eb21863c6448d14ea0555e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        '''The ID of the ENI that you want to attach.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46699c25e875aa0da863603cb428ced738d417364fcb7a74753571a623b15164)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="deleteOnTermination")
    def delete_on_termination(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Whether to delete the network interface when the instance terminates.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "deleteOnTermination"))

    @delete_on_termination.setter
    def delete_on_termination(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__95d995f5a17b7339e1633a46f4caf7b0334f3203bea60f5970be9e2f2a14077e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deleteOnTermination", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterfaceAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "device_index": "deviceIndex",
        "instance_id": "instanceId",
        "network_interface_id": "networkInterfaceId",
        "delete_on_termination": "deleteOnTermination",
    },
)
class CfnNetworkInterfaceAttachmentProps:
    def __init__(
        self,
        *,
        device_index: builtins.str,
        instance_id: builtins.str,
        network_interface_id: builtins.str,
        delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInterfaceAttachment``.

        :param device_index: The network interface's position in the attachment order. For example, the first attached network interface has a ``DeviceIndex`` of 0.
        :param instance_id: The ID of the instance to which you will attach the ENI.
        :param network_interface_id: The ID of the ENI that you want to attach.
        :param delete_on_termination: Whether to delete the network interface when the instance terminates. By default, this value is set to ``true`` . Default: - true

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_interface_attachment_props = ec2.CfnNetworkInterfaceAttachmentProps(
                device_index="deviceIndex",
                instance_id="instanceId",
                network_interface_id="networkInterfaceId",
            
                # the properties below are optional
                delete_on_termination=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b31ba98e2404b0fe712cc8951c65f1f317583a51d160007f9b90f285bb851816)
            check_type(argname="argument device_index", value=device_index, expected_type=type_hints["device_index"])
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "device_index": device_index,
            "instance_id": instance_id,
            "network_interface_id": network_interface_id,
        }
        if delete_on_termination is not None:
            self._values["delete_on_termination"] = delete_on_termination

    @builtins.property
    def device_index(self) -> builtins.str:
        '''The network interface's position in the attachment order.

        For example, the first attached network interface has a ``DeviceIndex`` of 0.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html#cfn-ec2-networkinterfaceattachment-deviceindex
        '''
        result = self._values.get("device_index")
        assert result is not None, "Required property 'device_index' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def instance_id(self) -> builtins.str:
        '''The ID of the instance to which you will attach the ENI.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html#cfn-ec2-networkinterfaceattachment-instanceid
        '''
        result = self._values.get("instance_id")
        assert result is not None, "Required property 'instance_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def network_interface_id(self) -> builtins.str:
        '''The ID of the ENI that you want to attach.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html#cfn-ec2-networkinterfaceattachment-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        assert result is not None, "Required property 'network_interface_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def delete_on_termination(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Whether to delete the network interface when the instance terminates.

        By default, this value is set to ``true`` .

        :default: - true

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfaceattachment.html#cfn-ec2-networkinterfaceattachment-deleteontermination
        '''
        result = self._values.get("delete_on_termination")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInterfaceAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnNetworkInterfacePermission(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterfacePermission",
):
    '''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.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfacepermission.html
    :cloudformationResource: AWS::EC2::NetworkInterfacePermission
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_interface_permission = ec2.CfnNetworkInterfacePermission(self, "MyCfnNetworkInterfacePermission",
            aws_account_id="awsAccountId",
            network_interface_id="networkInterfaceId",
            permission="permission"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        aws_account_id: builtins.str,
        network_interface_id: builtins.str,
        permission: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param aws_account_id: The AWS account ID.
        :param network_interface_id: The ID of the network interface.
        :param permission: The type of permission to grant: ``INSTANCE-ATTACH`` or ``EIP-ASSOCIATE`` .
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d04040d32749eaf3985c1db0ca5e7ab89686b04c123ac655d10a79d911798b72)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkInterfacePermissionProps(
            aws_account_id=aws_account_id,
            network_interface_id=network_interface_id,
            permission=permission,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6630593b6906e3e825645aa005b07fca83ded6bb20f59be204dd64d71cbef75f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a83f7be39b8ad366d5db2d2997e2890a011005f755783a103835e1ad3f3bfe82)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="awsAccountId")
    def aws_account_id(self) -> builtins.str:
        '''The AWS account ID.'''
        return typing.cast(builtins.str, jsii.get(self, "awsAccountId"))

    @aws_account_id.setter
    def aws_account_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f32b4b2dd695db2a3e55851e1666aa9581c8e0034cf76de07a65b5ae3a540528)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "awsAccountId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        '''The ID of the network interface.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__18507370afff5c5b540a79b3bb07ec48f9bed4f562f3c9166a720678592744d4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="permission")
    def permission(self) -> builtins.str:
        '''The type of permission to grant: ``INSTANCE-ATTACH`` or ``EIP-ASSOCIATE`` .'''
        return typing.cast(builtins.str, jsii.get(self, "permission"))

    @permission.setter
    def permission(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d12aa916b509342365796d7033c079bf6fe03d9bab12c347d2e743a6df67f051)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "permission", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterfacePermissionProps",
    jsii_struct_bases=[],
    name_mapping={
        "aws_account_id": "awsAccountId",
        "network_interface_id": "networkInterfaceId",
        "permission": "permission",
    },
)
class CfnNetworkInterfacePermissionProps:
    def __init__(
        self,
        *,
        aws_account_id: builtins.str,
        network_interface_id: builtins.str,
        permission: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInterfacePermission``.

        :param aws_account_id: The AWS account ID.
        :param network_interface_id: The ID of the network interface.
        :param permission: The type of permission to grant: ``INSTANCE-ATTACH`` or ``EIP-ASSOCIATE`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfacepermission.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_interface_permission_props = ec2.CfnNetworkInterfacePermissionProps(
                aws_account_id="awsAccountId",
                network_interface_id="networkInterfaceId",
                permission="permission"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__44e9326bdefcac87e9402f135aca64141cba9da3e221083d335c9f71322de46e)
            check_type(argname="argument aws_account_id", value=aws_account_id, expected_type=type_hints["aws_account_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument permission", value=permission, expected_type=type_hints["permission"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "aws_account_id": aws_account_id,
            "network_interface_id": network_interface_id,
            "permission": permission,
        }

    @builtins.property
    def aws_account_id(self) -> builtins.str:
        '''The AWS account ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfacepermission.html#cfn-ec2-networkinterfacepermission-awsaccountid
        '''
        result = self._values.get("aws_account_id")
        assert result is not None, "Required property 'aws_account_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def network_interface_id(self) -> builtins.str:
        '''The ID of the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfacepermission.html#cfn-ec2-networkinterfacepermission-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        assert result is not None, "Required property 'network_interface_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def permission(self) -> builtins.str:
        '''The type of permission to grant: ``INSTANCE-ATTACH`` or ``EIP-ASSOCIATE`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterfacepermission.html#cfn-ec2-networkinterfacepermission-permission
        '''
        result = self._values.get("permission")
        assert result is not None, "Required property 'permission' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInterfacePermissionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkInterfaceProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "connection_tracking_specification": "connectionTrackingSpecification",
        "description": "description",
        "enable_primary_ipv6": "enablePrimaryIpv6",
        "group_set": "groupSet",
        "interface_type": "interfaceType",
        "ipv4_prefix_count": "ipv4PrefixCount",
        "ipv4_prefixes": "ipv4Prefixes",
        "ipv6_address_count": "ipv6AddressCount",
        "ipv6_addresses": "ipv6Addresses",
        "ipv6_prefix_count": "ipv6PrefixCount",
        "ipv6_prefixes": "ipv6Prefixes",
        "private_ip_address": "privateIpAddress",
        "private_ip_addresses": "privateIpAddresses",
        "secondary_private_ip_address_count": "secondaryPrivateIpAddressCount",
        "source_dest_check": "sourceDestCheck",
        "tags": "tags",
    },
)
class CfnNetworkInterfaceProps:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.ConnectionTrackingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        description: typing.Optional[builtins.str] = None,
        enable_primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
        interface_type: typing.Optional[builtins.str] = None,
        ipv4_prefix_count: typing.Optional[jsii.Number] = None,
        ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv4PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ipv6_address_count: typing.Optional[jsii.Number] = None,
        ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ipv6_prefix_count: typing.Optional[jsii.Number] = None,
        ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv6PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.PrivateIpAddressSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
        source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnNetworkInterface``.

        :param subnet_id: The ID of the subnet to associate with the network interface.
        :param connection_tracking_specification: A connection tracking specification for the network interface.
        :param description: A description for the network interface.
        :param enable_primary_ipv6: 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.
        :param group_set: The security group IDs associated with this network interface.
        :param interface_type: The type of network interface. The default is ``interface`` . The supported values are ``efa`` and ``trunk`` .
        :param ipv4_prefix_count: 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.
        :param ipv4_prefixes: 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.
        :param ipv6_address_count: The number of IPv6 addresses to assign to a 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.
        :param ipv6_addresses: One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet to associate with 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.
        :param ipv6_prefix_count: 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.
        :param ipv6_prefixes: 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.
        :param private_ip_address: Assigns a single private IP address to the network interface, which is used as the primary private IP address. If you want to specify multiple private IP address, use the ``PrivateIpAddresses`` property.
        :param private_ip_addresses: Assigns private IP addresses 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.
        :param secondary_private_ip_address_count: 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.
        :param source_dest_check: 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.
        :param tags: An arbitrary set of tags (key-value pairs) for this network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_interface_props = ec2.CfnNetworkInterfaceProps(
                subnet_id="subnetId",
            
                # the properties below are optional
                connection_tracking_specification=ec2.CfnNetworkInterface.ConnectionTrackingSpecificationProperty(
                    tcp_established_timeout=123,
                    udp_stream_timeout=123,
                    udp_timeout=123
                ),
                description="description",
                enable_primary_ipv6=False,
                group_set=["groupSet"],
                interface_type="interfaceType",
                ipv4_prefix_count=123,
                ipv4_prefixes=[ec2.CfnNetworkInterface.Ipv4PrefixSpecificationProperty(
                    ipv4_prefix="ipv4Prefix"
                )],
                ipv6_address_count=123,
                ipv6_addresses=[ec2.CfnNetworkInterface.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )],
                ipv6_prefix_count=123,
                ipv6_prefixes=[ec2.CfnNetworkInterface.Ipv6PrefixSpecificationProperty(
                    ipv6_prefix="ipv6Prefix"
                )],
                private_ip_address="privateIpAddress",
                private_ip_addresses=[ec2.CfnNetworkInterface.PrivateIpAddressSpecificationProperty(
                    primary=False,
                    private_ip_address="privateIpAddress"
                )],
                secondary_private_ip_address_count=123,
                source_dest_check=False,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__419471c10f0cbd167ba77e8ca653474603529157eecae56a55b928c65c5bd8da)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument connection_tracking_specification", value=connection_tracking_specification, expected_type=type_hints["connection_tracking_specification"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument enable_primary_ipv6", value=enable_primary_ipv6, expected_type=type_hints["enable_primary_ipv6"])
            check_type(argname="argument group_set", value=group_set, expected_type=type_hints["group_set"])
            check_type(argname="argument interface_type", value=interface_type, expected_type=type_hints["interface_type"])
            check_type(argname="argument ipv4_prefix_count", value=ipv4_prefix_count, expected_type=type_hints["ipv4_prefix_count"])
            check_type(argname="argument ipv4_prefixes", value=ipv4_prefixes, expected_type=type_hints["ipv4_prefixes"])
            check_type(argname="argument ipv6_address_count", value=ipv6_address_count, expected_type=type_hints["ipv6_address_count"])
            check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
            check_type(argname="argument ipv6_prefix_count", value=ipv6_prefix_count, expected_type=type_hints["ipv6_prefix_count"])
            check_type(argname="argument ipv6_prefixes", value=ipv6_prefixes, expected_type=type_hints["ipv6_prefixes"])
            check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            check_type(argname="argument private_ip_addresses", value=private_ip_addresses, expected_type=type_hints["private_ip_addresses"])
            check_type(argname="argument secondary_private_ip_address_count", value=secondary_private_ip_address_count, expected_type=type_hints["secondary_private_ip_address_count"])
            check_type(argname="argument source_dest_check", value=source_dest_check, expected_type=type_hints["source_dest_check"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if connection_tracking_specification is not None:
            self._values["connection_tracking_specification"] = connection_tracking_specification
        if description is not None:
            self._values["description"] = description
        if enable_primary_ipv6 is not None:
            self._values["enable_primary_ipv6"] = enable_primary_ipv6
        if group_set is not None:
            self._values["group_set"] = group_set
        if interface_type is not None:
            self._values["interface_type"] = interface_type
        if ipv4_prefix_count is not None:
            self._values["ipv4_prefix_count"] = ipv4_prefix_count
        if ipv4_prefixes is not None:
            self._values["ipv4_prefixes"] = ipv4_prefixes
        if ipv6_address_count is not None:
            self._values["ipv6_address_count"] = ipv6_address_count
        if ipv6_addresses is not None:
            self._values["ipv6_addresses"] = ipv6_addresses
        if ipv6_prefix_count is not None:
            self._values["ipv6_prefix_count"] = ipv6_prefix_count
        if ipv6_prefixes is not None:
            self._values["ipv6_prefixes"] = ipv6_prefixes
        if private_ip_address is not None:
            self._values["private_ip_address"] = private_ip_address
        if private_ip_addresses is not None:
            self._values["private_ip_addresses"] = private_ip_addresses
        if secondary_private_ip_address_count is not None:
            self._values["secondary_private_ip_address_count"] = secondary_private_ip_address_count
        if source_dest_check is not None:
            self._values["source_dest_check"] = source_dest_check
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet to associate with the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def connection_tracking_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.ConnectionTrackingSpecificationProperty]]:
        '''A connection tracking specification for the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-connectiontrackingspecification
        '''
        result = self._values.get("connection_tracking_specification")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.ConnectionTrackingSpecificationProperty]], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enable_primary_ipv6(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-enableprimaryipv6
        '''
        result = self._values.get("enable_primary_ipv6")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def group_set(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The security group IDs associated with this network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-groupset
        '''
        result = self._values.get("group_set")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def interface_type(self) -> typing.Optional[builtins.str]:
        '''The type of network interface.

        The default is ``interface`` . The supported values are ``efa`` and ``trunk`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-interfacetype
        '''
        result = self._values.get("interface_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_prefix_count(self) -> typing.Optional[jsii.Number]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv4prefixcount
        '''
        result = self._values.get("ipv4_prefix_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv4_prefixes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv4PrefixSpecificationProperty]]]]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv4prefixes
        '''
        result = self._values.get("ipv4_prefixes")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv4PrefixSpecificationProperty]]]], result)

    @builtins.property
    def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
        '''The number of IPv6 addresses to assign to a 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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv6addresscount
        '''
        result = self._values.get("ipv6_address_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.InstanceIpv6AddressProperty]]]]:
        '''One or more specific IPv6 addresses from the IPv6 CIDR block range of your subnet to associate with 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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv6addresses
        '''
        result = self._values.get("ipv6_addresses")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.InstanceIpv6AddressProperty]]]], result)

    @builtins.property
    def ipv6_prefix_count(self) -> typing.Optional[jsii.Number]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv6prefixcount
        '''
        result = self._values.get("ipv6_prefix_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_prefixes(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv6PrefixSpecificationProperty]]]]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-ipv6prefixes
        '''
        result = self._values.get("ipv6_prefixes")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv6PrefixSpecificationProperty]]]], result)

    @builtins.property
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''Assigns a single private IP address to the network interface, which is used as the primary private IP address.

        If you want to specify multiple private IP address, use the ``PrivateIpAddresses`` property.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-privateipaddress
        '''
        result = self._values.get("private_ip_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def private_ip_addresses(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.PrivateIpAddressSpecificationProperty]]]]:
        '''Assigns private IP addresses 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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-privateipaddresses
        '''
        result = self._values.get("private_ip_addresses")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.PrivateIpAddressSpecificationProperty]]]], result)

    @builtins.property
    def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-secondaryprivateipaddresscount
        '''
        result = self._values.get("secondary_private_ip_address_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def source_dest_check(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-sourcedestcheck
        '''
        result = self._values.get("source_dest_check")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''An arbitrary set of tags (key-value pairs) for this network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkinterface.html#cfn-ec2-networkinterface-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkInterfaceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnNetworkPerformanceMetricSubscription(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkPerformanceMetricSubscription",
):
    '''Describes Infrastructure Performance subscriptions.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html
    :cloudformationResource: AWS::EC2::NetworkPerformanceMetricSubscription
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_network_performance_metric_subscription = ec2.CfnNetworkPerformanceMetricSubscription(self, "MyCfnNetworkPerformanceMetricSubscription",
            destination="destination",
            metric="metric",
            source="source",
            statistic="statistic"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        destination: builtins.str,
        metric: builtins.str,
        source: builtins.str,
        statistic: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param destination: The Region or Availability Zone that's the target for the subscription. For example, ``eu-west-1`` .
        :param metric: The metric used for the subscription.
        :param source: The Region or Availability Zone that's the source for the subscription. For example, ``us-east-1`` .
        :param statistic: The statistic used for the subscription.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8d839a4732c7183d1bfd72bdde3e65a5d7171baaefb0d8668061036128bf7fa)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnNetworkPerformanceMetricSubscriptionProps(
            destination=destination, metric=metric, source=source, statistic=statistic
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__527207c99eaebbb38efad5ba00945aa9cd9eb1944200862f44c3d4afc1fcc6e2)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cda4b0050e40ea9e827d36cb99a0e658ced602a74e11763bc9ae83fb41a6e441)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="destination")
    def destination(self) -> builtins.str:
        '''The Region or Availability Zone that's the target for the subscription.'''
        return typing.cast(builtins.str, jsii.get(self, "destination"))

    @destination.setter
    def destination(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aaa8f700005093a547dd057bef2ccb53e454f65307b085a9586f53f613954081)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destination", value)

    @builtins.property
    @jsii.member(jsii_name="metric")
    def metric(self) -> builtins.str:
        '''The metric used for the subscription.'''
        return typing.cast(builtins.str, jsii.get(self, "metric"))

    @metric.setter
    def metric(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d8013b3d594ef7e504666911164ceee162d4b7a9d7a6b3f9cd177c2d1c92d95)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "metric", value)

    @builtins.property
    @jsii.member(jsii_name="source")
    def source(self) -> builtins.str:
        '''The Region or Availability Zone that's the source for the subscription.'''
        return typing.cast(builtins.str, jsii.get(self, "source"))

    @source.setter
    def source(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7654c501c13366d2d7aabc76cc664028bc5f49222a9e4bbe79ee8952952d62d4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "source", value)

    @builtins.property
    @jsii.member(jsii_name="statistic")
    def statistic(self) -> builtins.str:
        '''The statistic used for the subscription.'''
        return typing.cast(builtins.str, jsii.get(self, "statistic"))

    @statistic.setter
    def statistic(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53342e79b1ba040609233c61600360c4528545cb0bde8de79f6cc245e23cadbe)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "statistic", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnNetworkPerformanceMetricSubscriptionProps",
    jsii_struct_bases=[],
    name_mapping={
        "destination": "destination",
        "metric": "metric",
        "source": "source",
        "statistic": "statistic",
    },
)
class CfnNetworkPerformanceMetricSubscriptionProps:
    def __init__(
        self,
        *,
        destination: builtins.str,
        metric: builtins.str,
        source: builtins.str,
        statistic: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnNetworkPerformanceMetricSubscription``.

        :param destination: The Region or Availability Zone that's the target for the subscription. For example, ``eu-west-1`` .
        :param metric: The metric used for the subscription.
        :param source: The Region or Availability Zone that's the source for the subscription. For example, ``us-east-1`` .
        :param statistic: The statistic used for the subscription.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_network_performance_metric_subscription_props = ec2.CfnNetworkPerformanceMetricSubscriptionProps(
                destination="destination",
                metric="metric",
                source="source",
                statistic="statistic"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd09b09944dd4da15b677a573d3eca3088dfd3191645c1594e6da952c55a22f5)
            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
            check_type(argname="argument source", value=source, expected_type=type_hints["source"])
            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "destination": destination,
            "metric": metric,
            "source": source,
            "statistic": statistic,
        }

    @builtins.property
    def destination(self) -> builtins.str:
        '''The Region or Availability Zone that's the target for the subscription.

        For example, ``eu-west-1`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html#cfn-ec2-networkperformancemetricsubscription-destination
        '''
        result = self._values.get("destination")
        assert result is not None, "Required property 'destination' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def metric(self) -> builtins.str:
        '''The metric used for the subscription.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html#cfn-ec2-networkperformancemetricsubscription-metric
        '''
        result = self._values.get("metric")
        assert result is not None, "Required property 'metric' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def source(self) -> builtins.str:
        '''The Region or Availability Zone that's the source for the subscription.

        For example, ``us-east-1`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html#cfn-ec2-networkperformancemetricsubscription-source
        '''
        result = self._values.get("source")
        assert result is not None, "Required property 'source' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def statistic(self) -> builtins.str:
        '''The statistic used for the subscription.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-networkperformancemetricsubscription.html#cfn-ec2-networkperformancemetricsubscription-statistic
        '''
        result = self._values.get("statistic")
        assert result is not None, "Required property 'statistic' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnNetworkPerformanceMetricSubscriptionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnPlacementGroup(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnPlacementGroup",
):
    '''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* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html
    :cloudformationResource: AWS::EC2::PlacementGroup
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_placement_group = ec2.CfnPlacementGroup(self, "MyCfnPlacementGroup",
            partition_count=123,
            spread_level="spreadLevel",
            strategy="strategy",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        partition_count: typing.Optional[jsii.Number] = None,
        spread_level: typing.Optional[builtins.str] = None,
        strategy: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param partition_count: The number of partitions. Valid only when *Strategy* is set to ``partition`` .
        :param spread_level: Determines how placement groups spread instances. - Host – You can use ``host`` only with Outpost placement groups. - Rack – No usage restrictions.
        :param strategy: The placement strategy.
        :param tags: The tags to apply to the new placement group.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a97e959453a7a8bdf073b17dd25f0fef03b744fe7cdb8e70900df3652bf8135)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnPlacementGroupProps(
            partition_count=partition_count,
            spread_level=spread_level,
            strategy=strategy,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__085b1a77e66c9da88ad57950d4d13acddc33a0de5d747c359b19fc24f824eb83)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60da1d74428021588b55a1b634d5e30603fd325314c71332bdd1673b924b8434)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupName")
    def attr_group_name(self) -> builtins.str:
        '''The name of the placement group.

        :cloudformationAttribute: GroupName
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrGroupName"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="partitionCount")
    def partition_count(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "partitionCount"))

    @partition_count.setter
    def partition_count(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__deeb2339c374b6f3d71d70e14c8ba3cb0726eaf3538217fbfbbf0beff83d87f1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "partitionCount", value)

    @builtins.property
    @jsii.member(jsii_name="spreadLevel")
    def spread_level(self) -> typing.Optional[builtins.str]:
        '''Determines how placement groups spread instances.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "spreadLevel"))

    @spread_level.setter
    def spread_level(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__019f535122ab6bb315651486be64d12d84c71f880b4a4e736d246b32953e0a7c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "spreadLevel", value)

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def strategy(self) -> typing.Optional[builtins.str]:
        '''The placement strategy.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "strategy"))

    @strategy.setter
    def strategy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58e6e68236c872d0e598f52a9948df6a54331b3506e5babf75a8de8e6327e9cc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "strategy", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the new placement group.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2a1ad80d3bb914b32525316054ff14b0ce299340d3090a1f9dce90cd3c50c0a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnPlacementGroupProps",
    jsii_struct_bases=[],
    name_mapping={
        "partition_count": "partitionCount",
        "spread_level": "spreadLevel",
        "strategy": "strategy",
        "tags": "tags",
    },
)
class CfnPlacementGroupProps:
    def __init__(
        self,
        *,
        partition_count: typing.Optional[jsii.Number] = None,
        spread_level: typing.Optional[builtins.str] = None,
        strategy: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnPlacementGroup``.

        :param partition_count: The number of partitions. Valid only when *Strategy* is set to ``partition`` .
        :param spread_level: Determines how placement groups spread instances. - Host – You can use ``host`` only with Outpost placement groups. - Rack – No usage restrictions.
        :param strategy: The placement strategy.
        :param tags: The tags to apply to the new placement group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_placement_group_props = ec2.CfnPlacementGroupProps(
                partition_count=123,
                spread_level="spreadLevel",
                strategy="strategy",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b7c1be4a84fce81f03bee89e965cb0205e9fc7599fb2de40c2bdb49aee8a1ca7)
            check_type(argname="argument partition_count", value=partition_count, expected_type=type_hints["partition_count"])
            check_type(argname="argument spread_level", value=spread_level, expected_type=type_hints["spread_level"])
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if partition_count is not None:
            self._values["partition_count"] = partition_count
        if spread_level is not None:
            self._values["spread_level"] = spread_level
        if strategy is not None:
            self._values["strategy"] = strategy
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def partition_count(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.

        Valid only when *Strategy* is set to ``partition`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html#cfn-ec2-placementgroup-partitioncount
        '''
        result = self._values.get("partition_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def spread_level(self) -> typing.Optional[builtins.str]:
        '''Determines how placement groups spread instances.

        - Host – You can use ``host`` only with Outpost placement groups.
        - Rack – No usage restrictions.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html#cfn-ec2-placementgroup-spreadlevel
        '''
        result = self._values.get("spread_level")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def strategy(self) -> typing.Optional[builtins.str]:
        '''The placement strategy.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html#cfn-ec2-placementgroup-strategy
        '''
        result = self._values.get("strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the new placement group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html#cfn-ec2-placementgroup-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnPlacementGroupProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnPrefixList(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnPrefixList",
):
    '''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.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html
    :cloudformationResource: AWS::EC2::PrefixList
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_prefix_list = ec2.CfnPrefixList(self, "MyCfnPrefixList",
            address_family="addressFamily",
            max_entries=123,
            prefix_list_name="prefixListName",
        
            # the properties below are optional
            entries=[ec2.CfnPrefixList.EntryProperty(
                cidr="cidr",
        
                # the properties below are optional
                description="description"
            )],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        address_family: builtins.str,
        max_entries: jsii.Number,
        prefix_list_name: builtins.str,
        entries: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPrefixList.EntryProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param address_family: The IP address type. Valid Values: ``IPv4`` | ``IPv6``
        :param max_entries: The maximum number of entries for the prefix list.
        :param prefix_list_name: A name for the prefix list. Constraints: Up to 255 characters in length. The name cannot start with ``com.amazonaws`` .
        :param entries: One or more entries for the prefix list.
        :param tags: The tags for the prefix list.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca40c21d744d74a8d12faa4a15d3401bfb9dfbec7caccc06e6b5e838a4539f19)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnPrefixListProps(
            address_family=address_family,
            max_entries=max_entries,
            prefix_list_name=prefix_list_name,
            entries=entries,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62322c706c8ccb56f4c1c382d594a4dd172bfc2026bcfaf8b6d57a0c1012f977)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a51658df7b5e126e6d4fc38aff0b123c13ff470cc34c2fd33c0b45b9d4f7297)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrArn")
    def attr_arn(self) -> builtins.str:
        '''The ARN of the prefix list.

        For example, ``arn:aws:ec2:us-east-1:123456789012:prefix-list/pl-0123123123123abcd`` .

        :cloudformationAttribute: Arn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrArn"))

    @builtins.property
    @jsii.member(jsii_name="attrOwnerId")
    def attr_owner_id(self) -> builtins.str:
        '''The ID of the owner of the prefix list.

        For example, ``123456789012`` .

        :cloudformationAttribute: OwnerId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwnerId"))

    @builtins.property
    @jsii.member(jsii_name="attrPrefixListId")
    def attr_prefix_list_id(self) -> builtins.str:
        '''The ID of the prefix list.

        For example, ``pl-0123123123123abcd`` .

        :cloudformationAttribute: PrefixListId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrPrefixListId"))

    @builtins.property
    @jsii.member(jsii_name="attrVersion")
    def attr_version(self) -> jsii.Number:
        '''The version of the prefix list.

        For example, ``1`` .

        :cloudformationAttribute: Version
        '''
        return typing.cast(jsii.Number, jsii.get(self, "attrVersion"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="addressFamily")
    def address_family(self) -> builtins.str:
        '''The IP address type.'''
        return typing.cast(builtins.str, jsii.get(self, "addressFamily"))

    @address_family.setter
    def address_family(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__543e8dfefad13c341bd9c21b253b583e2dfc0a1d6ec147009533000ad36a22f9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "addressFamily", value)

    @builtins.property
    @jsii.member(jsii_name="maxEntries")
    def max_entries(self) -> jsii.Number:
        '''The maximum number of entries for the prefix list.'''
        return typing.cast(jsii.Number, jsii.get(self, "maxEntries"))

    @max_entries.setter
    def max_entries(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ed7254f10519f5d8ac376f56a0f44399f3d7551f32d71c5509ea1ccd7c2a3cd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "maxEntries", value)

    @builtins.property
    @jsii.member(jsii_name="prefixListName")
    def prefix_list_name(self) -> builtins.str:
        '''A name for the prefix list.'''
        return typing.cast(builtins.str, jsii.get(self, "prefixListName"))

    @prefix_list_name.setter
    def prefix_list_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b27e5253beae7ef8a4554ded2f450182a10af89fc784f4ddc89aae6fc1df8dd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "prefixListName", value)

    @builtins.property
    @jsii.member(jsii_name="entries")
    def entries(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPrefixList.EntryProperty"]]]]:
        '''One or more entries for the prefix list.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPrefixList.EntryProperty"]]]], jsii.get(self, "entries"))

    @entries.setter
    def entries(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPrefixList.EntryProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__020c41fe6785b20283e5bef3edd50f44004ef8ff7348a874b2dc0f408c75985f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "entries", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the prefix list.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__712ae4f3a545a01afff1ee8200ddcf83e24e0045c90518644081a2620e86972b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnPrefixList.EntryProperty",
        jsii_struct_bases=[],
        name_mapping={"cidr": "cidr", "description": "description"},
    )
    class EntryProperty:
        def __init__(
            self,
            *,
            cidr: builtins.str,
            description: typing.Optional[builtins.str] = None,
        ) -> None:
            '''An entry for a prefix list.

            :param cidr: The CIDR block.
            :param description: A description for the entry. Constraints: Up to 255 characters in length.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-prefixlist-entry.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                entry_property = ec2.CfnPrefixList.EntryProperty(
                    cidr="cidr",
                
                    # the properties below are optional
                    description="description"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__836b191de61cf7c801ffbe6a52116262c188564ff3b6f7de40d432b6a80ba5b3)
                check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "cidr": cidr,
            }
            if description is not None:
                self._values["description"] = description

        @builtins.property
        def cidr(self) -> builtins.str:
            '''The CIDR block.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-prefixlist-entry.html#cfn-ec2-prefixlist-entry-cidr
            '''
            result = self._values.get("cidr")
            assert result is not None, "Required property 'cidr' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''A description for the entry.

            Constraints: Up to 255 characters in length.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-prefixlist-entry.html#cfn-ec2-prefixlist-entry-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EntryProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnPrefixListProps",
    jsii_struct_bases=[],
    name_mapping={
        "address_family": "addressFamily",
        "max_entries": "maxEntries",
        "prefix_list_name": "prefixListName",
        "entries": "entries",
        "tags": "tags",
    },
)
class CfnPrefixListProps:
    def __init__(
        self,
        *,
        address_family: builtins.str,
        max_entries: jsii.Number,
        prefix_list_name: builtins.str,
        entries: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnPrefixList``.

        :param address_family: The IP address type. Valid Values: ``IPv4`` | ``IPv6``
        :param max_entries: The maximum number of entries for the prefix list.
        :param prefix_list_name: A name for the prefix list. Constraints: Up to 255 characters in length. The name cannot start with ``com.amazonaws`` .
        :param entries: One or more entries for the prefix list.
        :param tags: The tags for the prefix list.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_prefix_list_props = ec2.CfnPrefixListProps(
                address_family="addressFamily",
                max_entries=123,
                prefix_list_name="prefixListName",
            
                # the properties below are optional
                entries=[ec2.CfnPrefixList.EntryProperty(
                    cidr="cidr",
            
                    # the properties below are optional
                    description="description"
                )],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ee3ea534076530da265ec0754410eb853bf7da980bbeaabb96d7fe30a9204813)
            check_type(argname="argument address_family", value=address_family, expected_type=type_hints["address_family"])
            check_type(argname="argument max_entries", value=max_entries, expected_type=type_hints["max_entries"])
            check_type(argname="argument prefix_list_name", value=prefix_list_name, expected_type=type_hints["prefix_list_name"])
            check_type(argname="argument entries", value=entries, expected_type=type_hints["entries"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "address_family": address_family,
            "max_entries": max_entries,
            "prefix_list_name": prefix_list_name,
        }
        if entries is not None:
            self._values["entries"] = entries
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def address_family(self) -> builtins.str:
        '''The IP address type.

        Valid Values: ``IPv4`` | ``IPv6``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html#cfn-ec2-prefixlist-addressfamily
        '''
        result = self._values.get("address_family")
        assert result is not None, "Required property 'address_family' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def max_entries(self) -> jsii.Number:
        '''The maximum number of entries for the prefix list.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html#cfn-ec2-prefixlist-maxentries
        '''
        result = self._values.get("max_entries")
        assert result is not None, "Required property 'max_entries' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def prefix_list_name(self) -> builtins.str:
        '''A name for the prefix list.

        Constraints: Up to 255 characters in length. The name cannot start with ``com.amazonaws`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html#cfn-ec2-prefixlist-prefixlistname
        '''
        result = self._values.get("prefix_list_name")
        assert result is not None, "Required property 'prefix_list_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def entries(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnPrefixList.EntryProperty]]]]:
        '''One or more entries for the prefix list.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html#cfn-ec2-prefixlist-entries
        '''
        result = self._values.get("entries")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnPrefixList.EntryProperty]]]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the prefix list.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-prefixlist.html#cfn-ec2-prefixlist-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnPrefixListProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnRoute(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnRoute",
):
    '''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.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html
    :cloudformationResource: AWS::EC2::Route
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_route = ec2.CfnRoute(self, "MyCfnRoute",
            route_table_id="routeTableId",
        
            # the properties below are optional
            carrier_gateway_id="carrierGatewayId",
            core_network_arn="coreNetworkArn",
            destination_cidr_block="destinationCidrBlock",
            destination_ipv6_cidr_block="destinationIpv6CidrBlock",
            destination_prefix_list_id="destinationPrefixListId",
            egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
            gateway_id="gatewayId",
            instance_id="instanceId",
            local_gateway_id="localGatewayId",
            nat_gateway_id="natGatewayId",
            network_interface_id="networkInterfaceId",
            transit_gateway_id="transitGatewayId",
            vpc_endpoint_id="vpcEndpointId",
            vpc_peering_connection_id="vpcPeeringConnectionId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        route_table_id: builtins.str,
        carrier_gateway_id: typing.Optional[builtins.str] = None,
        core_network_arn: typing.Optional[builtins.str] = None,
        destination_cidr_block: typing.Optional[builtins.str] = None,
        destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
        destination_prefix_list_id: typing.Optional[builtins.str] = None,
        egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
        gateway_id: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        local_gateway_id: typing.Optional[builtins.str] = None,
        nat_gateway_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        transit_gateway_id: typing.Optional[builtins.str] = None,
        vpc_endpoint_id: typing.Optional[builtins.str] = None,
        vpc_peering_connection_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param route_table_id: The ID of the route table for the route.
        :param carrier_gateway_id: 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.
        :param core_network_arn: The Amazon Resource Name (ARN) of the core network.
        :param destination_cidr_block: 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`` .
        :param destination_ipv6_cidr_block: The IPv6 CIDR block used for the destination match. Routing decisions are based on the most specific match.
        :param destination_prefix_list_id: The ID of a prefix list used for the destination match.
        :param egress_only_internet_gateway_id: [IPv6 traffic only] The ID of an egress-only internet gateway.
        :param gateway_id: The ID of an internet gateway or virtual private gateway attached to your VPC.
        :param instance_id: 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.
        :param local_gateway_id: The ID of the local gateway.
        :param nat_gateway_id: [IPv4 traffic only] The ID of a NAT gateway.
        :param network_interface_id: The ID of a network interface.
        :param transit_gateway_id: The ID of a transit gateway.
        :param vpc_endpoint_id: The ID of a VPC endpoint. Supported for Gateway Load Balancer endpoints only.
        :param vpc_peering_connection_id: The ID of a VPC peering connection.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__418aadfc2c6984f0ac75cd67e36ca76f23d9cf7bc23846cf55d7b3cdbd691797)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnRouteProps(
            route_table_id=route_table_id,
            carrier_gateway_id=carrier_gateway_id,
            core_network_arn=core_network_arn,
            destination_cidr_block=destination_cidr_block,
            destination_ipv6_cidr_block=destination_ipv6_cidr_block,
            destination_prefix_list_id=destination_prefix_list_id,
            egress_only_internet_gateway_id=egress_only_internet_gateway_id,
            gateway_id=gateway_id,
            instance_id=instance_id,
            local_gateway_id=local_gateway_id,
            nat_gateway_id=nat_gateway_id,
            network_interface_id=network_interface_id,
            transit_gateway_id=transit_gateway_id,
            vpc_endpoint_id=vpc_endpoint_id,
            vpc_peering_connection_id=vpc_peering_connection_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6be65f2a156289dba30c6b64726cb3622e229f7b1e4e152487bbd9e0ecfb9d7d)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a9bb73be2078411a9f0d4740a463a6f77c635fe220f5351d3fc9e0f442d2061)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCidrBlock")
    def attr_cidr_block(self) -> builtins.str:
        '''The IPv4 CIDR block.

        :cloudformationAttribute: CidrBlock
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="routeTableId")
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table for the route.'''
        return typing.cast(builtins.str, jsii.get(self, "routeTableId"))

    @route_table_id.setter
    def route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8db87996585873368487fc20df4ef16915a47f32a4459b4643d211faf6b65dc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "routeTableId", value)

    @builtins.property
    @jsii.member(jsii_name="carrierGatewayId")
    def carrier_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the carrier gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "carrierGatewayId"))

    @carrier_gateway_id.setter
    def carrier_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__355c5c80f08453332882507836cf0441e37ed4a5c9fa46ef1c415dd739491b7e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "carrierGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="coreNetworkArn")
    def core_network_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the core network.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "coreNetworkArn"))

    @core_network_arn.setter
    def core_network_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__535edefe9ec250f819eacd60779bcf6b8d4afa9cd9b9ec8142ddfb03034be5ac)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "coreNetworkArn", value)

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR address block used for the destination match.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ae05f819fd9822a84fcac1033a9bd983835b0e75eb0d432aa89d5973585cc3e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="destinationIpv6CidrBlock")
    def destination_ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block used for the destination match.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationIpv6CidrBlock"))

    @destination_ipv6_cidr_block.setter
    def destination_ipv6_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9053d56266f2ecaa5d8209e05a5af048fd6c8540eece0de592fa617598e87e30)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationIpv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="destinationPrefixListId")
    def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a prefix list used for the destination match.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationPrefixListId"))

    @destination_prefix_list_id.setter
    def destination_prefix_list_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28b2d9e818763b23c1689ff8d32ac779a6cdf2e20e4e1b57f65f0f3474ae8878)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationPrefixListId", value)

    @builtins.property
    @jsii.member(jsii_name="egressOnlyInternetGatewayId")
    def egress_only_internet_gateway_id(self) -> typing.Optional[builtins.str]:
        '''[IPv6 traffic only] The ID of an egress-only internet gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "egressOnlyInternetGatewayId"))

    @egress_only_internet_gateway_id.setter
    def egress_only_internet_gateway_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d8f8dcc844a05743d981c217d51303c0c4cc6e46dadd5339a6eb261fe327b128)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "egressOnlyInternetGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="gatewayId")
    def gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of an internet gateway or virtual private gateway attached to your VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "gatewayId"))

    @gateway_id.setter
    def gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c49944ede227d758c602f9702b54e035d5067af2a0424d3b194ba7311c44aea8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "gatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a NAT instance in your VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceId"))

    @instance_id.setter
    def instance_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d987c0fc0a014587365521959275a5a66f3fb9212aa1ef3e47b13ec24a3291a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceId", value)

    @builtins.property
    @jsii.member(jsii_name="localGatewayId")
    def local_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the local gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "localGatewayId"))

    @local_gateway_id.setter
    def local_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46d262dfaa3881555d65a46e9b26bc3ad572270d792880fa9867825c43d6b51c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="natGatewayId")
    def nat_gateway_id(self) -> typing.Optional[builtins.str]:
        '''[IPv4 traffic only] The ID of a NAT gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "natGatewayId"))

    @nat_gateway_id.setter
    def nat_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a847890b57b0439222d2d701c672a84c0722c931f9b262edafa5fed2a6e2f84b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "natGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a network interface.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__266f068b50cc854a81450a8d5e3e82022666389ba782b94a359557a139812aef)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a transit gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82c38d5de8dba90584bc4953ed11041cd571a5742b7358ca8dbaa9d4ce4aa9bd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a VPC endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcEndpointId"))

    @vpc_endpoint_id.setter
    def vpc_endpoint_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b3588c8e5a495d9ab8a2699ed72f7253e15605bba594e43b65e5892bcbf1ca0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcEndpointId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcPeeringConnectionId")
    def vpc_peering_connection_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a VPC peering connection.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcPeeringConnectionId"))

    @vpc_peering_connection_id.setter
    def vpc_peering_connection_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46892d5dd1581aee0dcf6410687f88cfaffdfdd18c726880534edc8f86e9919a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcPeeringConnectionId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnRouteProps",
    jsii_struct_bases=[],
    name_mapping={
        "route_table_id": "routeTableId",
        "carrier_gateway_id": "carrierGatewayId",
        "core_network_arn": "coreNetworkArn",
        "destination_cidr_block": "destinationCidrBlock",
        "destination_ipv6_cidr_block": "destinationIpv6CidrBlock",
        "destination_prefix_list_id": "destinationPrefixListId",
        "egress_only_internet_gateway_id": "egressOnlyInternetGatewayId",
        "gateway_id": "gatewayId",
        "instance_id": "instanceId",
        "local_gateway_id": "localGatewayId",
        "nat_gateway_id": "natGatewayId",
        "network_interface_id": "networkInterfaceId",
        "transit_gateway_id": "transitGatewayId",
        "vpc_endpoint_id": "vpcEndpointId",
        "vpc_peering_connection_id": "vpcPeeringConnectionId",
    },
)
class CfnRouteProps:
    def __init__(
        self,
        *,
        route_table_id: builtins.str,
        carrier_gateway_id: typing.Optional[builtins.str] = None,
        core_network_arn: typing.Optional[builtins.str] = None,
        destination_cidr_block: typing.Optional[builtins.str] = None,
        destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
        destination_prefix_list_id: typing.Optional[builtins.str] = None,
        egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
        gateway_id: typing.Optional[builtins.str] = None,
        instance_id: typing.Optional[builtins.str] = None,
        local_gateway_id: typing.Optional[builtins.str] = None,
        nat_gateway_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        transit_gateway_id: typing.Optional[builtins.str] = None,
        vpc_endpoint_id: typing.Optional[builtins.str] = None,
        vpc_peering_connection_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnRoute``.

        :param route_table_id: The ID of the route table for the route.
        :param carrier_gateway_id: 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.
        :param core_network_arn: The Amazon Resource Name (ARN) of the core network.
        :param destination_cidr_block: 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`` .
        :param destination_ipv6_cidr_block: The IPv6 CIDR block used for the destination match. Routing decisions are based on the most specific match.
        :param destination_prefix_list_id: The ID of a prefix list used for the destination match.
        :param egress_only_internet_gateway_id: [IPv6 traffic only] The ID of an egress-only internet gateway.
        :param gateway_id: The ID of an internet gateway or virtual private gateway attached to your VPC.
        :param instance_id: 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.
        :param local_gateway_id: The ID of the local gateway.
        :param nat_gateway_id: [IPv4 traffic only] The ID of a NAT gateway.
        :param network_interface_id: The ID of a network interface.
        :param transit_gateway_id: The ID of a transit gateway.
        :param vpc_endpoint_id: The ID of a VPC endpoint. Supported for Gateway Load Balancer endpoints only.
        :param vpc_peering_connection_id: The ID of a VPC peering connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_route_props = ec2.CfnRouteProps(
                route_table_id="routeTableId",
            
                # the properties below are optional
                carrier_gateway_id="carrierGatewayId",
                core_network_arn="coreNetworkArn",
                destination_cidr_block="destinationCidrBlock",
                destination_ipv6_cidr_block="destinationIpv6CidrBlock",
                destination_prefix_list_id="destinationPrefixListId",
                egress_only_internet_gateway_id="egressOnlyInternetGatewayId",
                gateway_id="gatewayId",
                instance_id="instanceId",
                local_gateway_id="localGatewayId",
                nat_gateway_id="natGatewayId",
                network_interface_id="networkInterfaceId",
                transit_gateway_id="transitGatewayId",
                vpc_endpoint_id="vpcEndpointId",
                vpc_peering_connection_id="vpcPeeringConnectionId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f90e7814d59b7c562ab4b24d54461eba6a4c88fbd5451ba2b2b0adf8441a452e)
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
            check_type(argname="argument carrier_gateway_id", value=carrier_gateway_id, expected_type=type_hints["carrier_gateway_id"])
            check_type(argname="argument core_network_arn", value=core_network_arn, expected_type=type_hints["core_network_arn"])
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument destination_ipv6_cidr_block", value=destination_ipv6_cidr_block, expected_type=type_hints["destination_ipv6_cidr_block"])
            check_type(argname="argument destination_prefix_list_id", value=destination_prefix_list_id, expected_type=type_hints["destination_prefix_list_id"])
            check_type(argname="argument egress_only_internet_gateway_id", value=egress_only_internet_gateway_id, expected_type=type_hints["egress_only_internet_gateway_id"])
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
            check_type(argname="argument local_gateway_id", value=local_gateway_id, expected_type=type_hints["local_gateway_id"])
            check_type(argname="argument nat_gateway_id", value=nat_gateway_id, expected_type=type_hints["nat_gateway_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument vpc_endpoint_id", value=vpc_endpoint_id, expected_type=type_hints["vpc_endpoint_id"])
            check_type(argname="argument vpc_peering_connection_id", value=vpc_peering_connection_id, expected_type=type_hints["vpc_peering_connection_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "route_table_id": route_table_id,
        }
        if carrier_gateway_id is not None:
            self._values["carrier_gateway_id"] = carrier_gateway_id
        if core_network_arn is not None:
            self._values["core_network_arn"] = core_network_arn
        if destination_cidr_block is not None:
            self._values["destination_cidr_block"] = destination_cidr_block
        if destination_ipv6_cidr_block is not None:
            self._values["destination_ipv6_cidr_block"] = destination_ipv6_cidr_block
        if destination_prefix_list_id is not None:
            self._values["destination_prefix_list_id"] = destination_prefix_list_id
        if egress_only_internet_gateway_id is not None:
            self._values["egress_only_internet_gateway_id"] = egress_only_internet_gateway_id
        if gateway_id is not None:
            self._values["gateway_id"] = gateway_id
        if instance_id is not None:
            self._values["instance_id"] = instance_id
        if local_gateway_id is not None:
            self._values["local_gateway_id"] = local_gateway_id
        if nat_gateway_id is not None:
            self._values["nat_gateway_id"] = nat_gateway_id
        if network_interface_id is not None:
            self._values["network_interface_id"] = network_interface_id
        if transit_gateway_id is not None:
            self._values["transit_gateway_id"] = transit_gateway_id
        if vpc_endpoint_id is not None:
            self._values["vpc_endpoint_id"] = vpc_endpoint_id
        if vpc_peering_connection_id is not None:
            self._values["vpc_peering_connection_id"] = vpc_peering_connection_id

    @builtins.property
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table for the route.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-routetableid
        '''
        result = self._values.get("route_table_id")
        assert result is not None, "Required property 'route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def carrier_gateway_id(self) -> typing.Optional[builtins.str]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-carriergatewayid
        '''
        result = self._values.get("carrier_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def core_network_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the core network.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-corenetworkarn
        '''
        result = self._values.get("core_network_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_cidr_block(self) -> typing.Optional[builtins.str]:
        '''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`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block used for the destination match.

        Routing decisions are based on the most specific match.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-destinationipv6cidrblock
        '''
        result = self._values.get("destination_ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a prefix list used for the destination match.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-destinationprefixlistid
        '''
        result = self._values.get("destination_prefix_list_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def egress_only_internet_gateway_id(self) -> typing.Optional[builtins.str]:
        '''[IPv6 traffic only] The ID of an egress-only internet gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-egressonlyinternetgatewayid
        '''
        result = self._values.get("egress_only_internet_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of an internet gateway or virtual private gateway attached to your VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-gatewayid
        '''
        result = self._values.get("gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def instance_id(self) -> typing.Optional[builtins.str]:
        '''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.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-instanceid
        '''
        result = self._values.get("instance_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def local_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the local gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-localgatewayid
        '''
        result = self._values.get("local_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def nat_gateway_id(self) -> typing.Optional[builtins.str]:
        '''[IPv4 traffic only] The ID of a NAT gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-natgatewayid
        '''
        result = self._values.get("nat_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def transit_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a VPC endpoint.

        Supported for Gateway Load Balancer endpoints only.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-vpcendpointid
        '''
        result = self._values.get("vpc_endpoint_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_peering_connection_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a VPC peering connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html#cfn-ec2-route-vpcpeeringconnectionid
        '''
        result = self._values.get("vpc_peering_connection_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnRouteTable(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnRouteTable",
):
    '''Specifies a route table for the specified VPC.

    After you create a route table, you can add routes and associate the table with a subnet.

    For more information, see `Route tables <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-routetable.html
    :cloudformationResource: AWS::EC2::RouteTable
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_route_table = ec2.CfnRouteTable(self, "MyCfnRouteTable",
            vpc_id="vpcId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC.
        :param tags: Any tags assigned to the route table.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__93a1e7c740b947cc510161b87d4afa4b057e501067ea1f7ef24fdb6a8ab5614c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnRouteTableProps(vpc_id=vpc_id, tags=tags)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cff9836624fcf3040188660643f84ea5ed967e0aefb5879689106d7a284610f8)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__210d22ba03739538d1e761f7e067657a2a7df6962e5beadc43dbfbaf9959ba5d)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrRouteTableId")
    def attr_route_table_id(self) -> builtins.str:
        '''The ID of the route table.

        :cloudformationAttribute: RouteTableId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrRouteTableId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7817c70f941079d8bd72522227f92459adefb6aa05d21e93a59b57d500b7fa4f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the route table.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1f72e62e1c77480bfaac479cdae53d464d07797246a34e3cc9551335c3da767)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnRouteTableProps",
    jsii_struct_bases=[],
    name_mapping={"vpc_id": "vpcId", "tags": "tags"},
)
class CfnRouteTableProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnRouteTable``.

        :param vpc_id: The ID of the VPC.
        :param tags: Any tags assigned to the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-routetable.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_route_table_props = ec2.CfnRouteTableProps(
                vpc_id="vpcId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ed47752a654feace43cbbb783b95bbd42507e651168521e8b12b49c07d72609)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-routetable.html#cfn-ec2-routetable-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-routetable.html#cfn-ec2-routetable-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnRouteTableProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnSecurityGroup(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroup",
):
    '''Specifies a security group.

    To create a security group, use the `VpcId <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html#cfn-ec2-securitygroup-vpcid>`_ property to specify the VPC for which to create the security group.

    If you do not specify an egress rule, we add egress rules that allow IPv4 and IPv6 traffic on all ports and protocols to any destination. We do not add these rules if you specify your own egress rules. If you later remove your egress rules, we restore the default egress rules.

    This type supports updates. For more information about updating stacks, see `AWS CloudFormation Stacks Updates <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks.html>`_ .
    .. epigraph::

       To cross-reference two security groups in the ingress and egress rules of those security groups, use the `AWS::EC2::SecurityGroupEgress <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-security-group-egress.html>`_ and `AWS::EC2::SecurityGroupIngress <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-security-group-ingress.html>`_ resources to define your rules. Do not use the embedded ingress and egress rules in the ``AWS::EC2::SecurityGroup`` . Doing so creates a circular dependency, which AWS CloudFormation doesn't allow.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html
    :cloudformationResource: AWS::EC2::SecurityGroup
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_security_group = ec2.CfnSecurityGroup(self, "MyCfnSecurityGroup",
            group_description="groupDescription",
        
            # the properties below are optional
            group_name="groupName",
            security_group_egress=[ec2.CfnSecurityGroup.EgressProperty(
                ip_protocol="ipProtocol",
        
                # the properties below are optional
                cidr_ip="cidrIp",
                cidr_ipv6="cidrIpv6",
                description="description",
                destination_prefix_list_id="destinationPrefixListId",
                destination_security_group_id="destinationSecurityGroupId",
                from_port=123,
                to_port=123
            )],
            security_group_ingress=[ec2.CfnSecurityGroup.IngressProperty(
                ip_protocol="ipProtocol",
        
                # the properties below are optional
                cidr_ip="cidrIp",
                cidr_ipv6="cidrIpv6",
                description="description",
                from_port=123,
                source_prefix_list_id="sourcePrefixListId",
                source_security_group_id="sourceSecurityGroupId",
                source_security_group_name="sourceSecurityGroupName",
                source_security_group_owner_id="sourceSecurityGroupOwnerId",
                to_port=123
            )],
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            vpc_id="vpcId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        group_description: builtins.str,
        group_name: typing.Optional[builtins.str] = None,
        security_group_egress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSecurityGroup.EgressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        security_group_ingress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSecurityGroup.IngressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param group_description: A description for the security group. Constraints: Up to 255 characters in length Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param group_name: The name of the security group. Constraints: Up to 255 characters in length. Cannot start with ``sg-`` . Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param security_group_egress: The outbound rules associated with the security group. There is a short interruption during which you cannot connect to the security group.
        :param security_group_ingress: The inbound rules associated with the security group. There is a short interruption during which you cannot connect to the security group.
        :param tags: Any tags assigned to the security group.
        :param vpc_id: The ID of the VPC for the security group. If you do not specify a VPC, the default is to use the default VPC for the Region. If there's no specified VPC and no default VPC, security group creation fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d683e3d98ba1cf2002a34b5f2c1fd4a4321e62dc852c644de658a8cac860b36)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSecurityGroupProps(
            group_description=group_description,
            group_name=group_name,
            security_group_egress=security_group_egress,
            security_group_ingress=security_group_ingress,
            tags=tags,
            vpc_id=vpc_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__946b476b6f9040093c97a64d3216b8b663100aa6248e967683a518f613c6650d)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a9218d8e00e7a6968dfa94cde1763f41e4b171ef6f953ebe5b263feb896fce9)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupId")
    def attr_group_id(self) -> builtins.str:
        '''The group ID of the specified security group, such as ``sg-94b3a1f6`` .

        :cloudformationAttribute: GroupId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrGroupId"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrVpcId")
    def attr_vpc_id(self) -> builtins.str:
        '''The physical ID of the VPC.

        You can obtain the physical ID by using a reference to an `AWS::EC2::VPC <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html>`_ , such as: ``{ "Ref" : "myVPC" }`` .

        :cloudformationAttribute: VpcId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpcId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="groupDescription")
    def group_description(self) -> builtins.str:
        '''A description for the security group.'''
        return typing.cast(builtins.str, jsii.get(self, "groupDescription"))

    @group_description.setter
    def group_description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__17ccc6763068e002855069b1934ac3408a3db7f3bb73ce74a6e7a0eceb80cbb1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupDescription", value)

    @builtins.property
    @jsii.member(jsii_name="groupName")
    def group_name(self) -> typing.Optional[builtins.str]:
        '''The name of the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "groupName"))

    @group_name.setter
    def group_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__735e91dbf5286e6f0c6a7dc175aed5716375fba630ee09473401e3cb4c27990d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupName", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupEgress")
    def security_group_egress(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.EgressProperty"]]]]:
        '''The outbound rules associated with the security group.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.EgressProperty"]]]], jsii.get(self, "securityGroupEgress"))

    @security_group_egress.setter
    def security_group_egress(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.EgressProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e697e16c1dc9b050f938d76c69dd4315144185a4d193fc14e6411676b9f0add2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupEgress", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIngress")
    def security_group_ingress(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.IngressProperty"]]]]:
        '''The inbound rules associated with the security group.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.IngressProperty"]]]], jsii.get(self, "securityGroupIngress"))

    @security_group_ingress.setter
    def security_group_ingress(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSecurityGroup.IngressProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__657a86e3aa98e6280b9cf9b7e38fcffcdaa2731104733314d42378aaa68c3fdd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIngress", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the security group.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__320649c55eced315e2f22059c7d31c15f5ec1871be4f9915f220a08b74772226)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the VPC for the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61d4413792ac35911ce993c205d95f44fc3caa0ffb0d0cc412772dfe65fd7dd3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroup.EgressProperty",
        jsii_struct_bases=[],
        name_mapping={
            "ip_protocol": "ipProtocol",
            "cidr_ip": "cidrIp",
            "cidr_ipv6": "cidrIpv6",
            "description": "description",
            "destination_prefix_list_id": "destinationPrefixListId",
            "destination_security_group_id": "destinationSecurityGroupId",
            "from_port": "fromPort",
            "to_port": "toPort",
        },
    )
    class EgressProperty:
        def __init__(
            self,
            *,
            ip_protocol: builtins.str,
            cidr_ip: typing.Optional[builtins.str] = None,
            cidr_ipv6: typing.Optional[builtins.str] = None,
            description: typing.Optional[builtins.str] = None,
            destination_prefix_list_id: typing.Optional[builtins.str] = None,
            destination_security_group_id: typing.Optional[builtins.str] = None,
            from_port: typing.Optional[jsii.Number] = None,
            to_port: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Adds the specified outbound (egress) rule to a security group.

            An outbound rule permits instances to send traffic to the specified IPv4 or IPv6 address range, the IP address ranges that are specified by a prefix list, or the instances that are associated with a destination security group. For more information, see `Security group rules <https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html>`_ .

            You must specify exactly one of the following destinations: an IPv4 or IPv6 address range, a prefix list, or a security group. Otherwise, the stack launches successfully but the rule is not added to the security group.

            You must specify a protocol for each rule (for example, TCP). If the protocol is TCP or UDP, you must also specify a port or port range. If the protocol is ICMP or ICMPv6, you must also specify the ICMP/ICMPv6 type and code.

            Rule changes are propagated to instances associated with the security group as quickly as possible. However, a small delay might occur.

            :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
            :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
            :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
            :param description: A description for the security group rule. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
            :param destination_prefix_list_id: The prefix list IDs for the destination AWS service. This is the AWS service that you want to access through a VPC endpoint from instances associated with the security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
            :param destination_security_group_id: The ID of the destination VPC security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
            :param from_port: If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).
            :param to_port: If the protocol is TCP or UDP, this is the end of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                egress_property = ec2.CfnSecurityGroup.EgressProperty(
                    ip_protocol="ipProtocol",
                
                    # the properties below are optional
                    cidr_ip="cidrIp",
                    cidr_ipv6="cidrIpv6",
                    description="description",
                    destination_prefix_list_id="destinationPrefixListId",
                    destination_security_group_id="destinationSecurityGroupId",
                    from_port=123,
                    to_port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f7f9c3e8bd9fe395c2fb15fd9d38e6ef1ebca888c954597574840d2026080b54)
                check_type(argname="argument ip_protocol", value=ip_protocol, expected_type=type_hints["ip_protocol"])
                check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
                check_type(argname="argument cidr_ipv6", value=cidr_ipv6, expected_type=type_hints["cidr_ipv6"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument destination_prefix_list_id", value=destination_prefix_list_id, expected_type=type_hints["destination_prefix_list_id"])
                check_type(argname="argument destination_security_group_id", value=destination_security_group_id, expected_type=type_hints["destination_security_group_id"])
                check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
                check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ip_protocol": ip_protocol,
            }
            if cidr_ip is not None:
                self._values["cidr_ip"] = cidr_ip
            if cidr_ipv6 is not None:
                self._values["cidr_ipv6"] = cidr_ipv6
            if description is not None:
                self._values["description"] = description
            if destination_prefix_list_id is not None:
                self._values["destination_prefix_list_id"] = destination_prefix_list_id
            if destination_security_group_id is not None:
                self._values["destination_security_group_id"] = destination_security_group_id
            if from_port is not None:
                self._values["from_port"] = from_port
            if to_port is not None:
                self._values["to_port"] = to_port

        @builtins.property
        def ip_protocol(self) -> builtins.str:
            '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).

            Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-ipprotocol
            '''
            result = self._values.get("ip_protocol")
            assert result is not None, "Required property 'ip_protocol' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def cidr_ip(self) -> typing.Optional[builtins.str]:
            '''The IPv4 address range, in CIDR format.

            You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-cidrip
            '''
            result = self._values.get("cidr_ip")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cidr_ipv6(self) -> typing.Optional[builtins.str]:
            '''The IPv6 address range, in CIDR format.

            You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-cidripv6
            '''
            result = self._values.get("cidr_ipv6")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''A description for the security group rule.

            Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
            '''The prefix list IDs for the destination AWS service.

            This is the AWS service that you want to access through a VPC endpoint from instances associated with the security group.

            You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-destinationprefixlistid
            '''
            result = self._values.get("destination_prefix_list_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def destination_security_group_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the destination VPC security group.

            You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-destinationsecuritygroupid
            '''
            result = self._values.get("destination_security_group_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def from_port(self) -> typing.Optional[jsii.Number]:
            '''If the protocol is TCP or UDP, this is the start of the port range.

            If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-fromport
            '''
            result = self._values.get("from_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def to_port(self) -> typing.Optional[jsii.Number]:
            '''If the protocol is TCP or UDP, this is the end of the port range.

            If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-egress.html#cfn-ec2-securitygroup-egress-toport
            '''
            result = self._values.get("to_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EgressProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroup.IngressProperty",
        jsii_struct_bases=[],
        name_mapping={
            "ip_protocol": "ipProtocol",
            "cidr_ip": "cidrIp",
            "cidr_ipv6": "cidrIpv6",
            "description": "description",
            "from_port": "fromPort",
            "source_prefix_list_id": "sourcePrefixListId",
            "source_security_group_id": "sourceSecurityGroupId",
            "source_security_group_name": "sourceSecurityGroupName",
            "source_security_group_owner_id": "sourceSecurityGroupOwnerId",
            "to_port": "toPort",
        },
    )
    class IngressProperty:
        def __init__(
            self,
            *,
            ip_protocol: builtins.str,
            cidr_ip: typing.Optional[builtins.str] = None,
            cidr_ipv6: typing.Optional[builtins.str] = None,
            description: typing.Optional[builtins.str] = None,
            from_port: typing.Optional[jsii.Number] = None,
            source_prefix_list_id: typing.Optional[builtins.str] = None,
            source_security_group_id: typing.Optional[builtins.str] = None,
            source_security_group_name: typing.Optional[builtins.str] = None,
            source_security_group_owner_id: typing.Optional[builtins.str] = None,
            to_port: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Adds an inbound (ingress) rule to a security group.

            An inbound rule permits instances to receive traffic from the specified IPv4 or IPv6 address range, the IP address ranges that are specified by a prefix list, or the instances that are associated with a source security group. For more information, see `Security group rules <https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html>`_ .

            You must specify exactly one of the following sources: an IPv4 or IPv6 address range, a prefix list, or a security group. Otherwise, the stack launches successfully, but the rule is not added to the security group.

            You must specify a protocol for each rule (for example, TCP). If the protocol is TCP or UDP, you must also specify a port or port range. If the protocol is ICMP or ICMPv6, you must also specify the ICMP/ICMPv6 type and code.

            Rule changes are propagated to instances associated with the security group as quickly as possible. However, a small delay might occur.

            :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
            :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
            :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
            :param description: Updates the description of an ingress (inbound) security group rule. You can replace an existing description, or add a description to a rule that did not have one previously. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
            :param from_port: If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).
            :param source_prefix_list_id: The ID of a prefix list.
            :param source_security_group_id: The ID of the security group.
            :param source_security_group_name: [Default VPC] The name of the source security group. You must specify either the security group ID or the security group name. You can't specify the group name in combination with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. For security groups in a nondefault VPC, you must specify the group ID.
            :param source_security_group_owner_id: [nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account. You can't specify this property with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. If you specify ``SourceSecurityGroupName`` or ``SourceSecurityGroupId`` and that security group is owned by a different account than the account creating the stack, you must specify the ``SourceSecurityGroupOwnerId`` ; otherwise, this property is optional.
            :param to_port: If the protocol is TCP or UDP, this is the end of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ingress_property = ec2.CfnSecurityGroup.IngressProperty(
                    ip_protocol="ipProtocol",
                
                    # the properties below are optional
                    cidr_ip="cidrIp",
                    cidr_ipv6="cidrIpv6",
                    description="description",
                    from_port=123,
                    source_prefix_list_id="sourcePrefixListId",
                    source_security_group_id="sourceSecurityGroupId",
                    source_security_group_name="sourceSecurityGroupName",
                    source_security_group_owner_id="sourceSecurityGroupOwnerId",
                    to_port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__0c5b613c6071e52a9a418d9a5233b95303a864edfa1054ce34648a49a7c6a39b)
                check_type(argname="argument ip_protocol", value=ip_protocol, expected_type=type_hints["ip_protocol"])
                check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
                check_type(argname="argument cidr_ipv6", value=cidr_ipv6, expected_type=type_hints["cidr_ipv6"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
                check_type(argname="argument source_prefix_list_id", value=source_prefix_list_id, expected_type=type_hints["source_prefix_list_id"])
                check_type(argname="argument source_security_group_id", value=source_security_group_id, expected_type=type_hints["source_security_group_id"])
                check_type(argname="argument source_security_group_name", value=source_security_group_name, expected_type=type_hints["source_security_group_name"])
                check_type(argname="argument source_security_group_owner_id", value=source_security_group_owner_id, expected_type=type_hints["source_security_group_owner_id"])
                check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ip_protocol": ip_protocol,
            }
            if cidr_ip is not None:
                self._values["cidr_ip"] = cidr_ip
            if cidr_ipv6 is not None:
                self._values["cidr_ipv6"] = cidr_ipv6
            if description is not None:
                self._values["description"] = description
            if from_port is not None:
                self._values["from_port"] = from_port
            if source_prefix_list_id is not None:
                self._values["source_prefix_list_id"] = source_prefix_list_id
            if source_security_group_id is not None:
                self._values["source_security_group_id"] = source_security_group_id
            if source_security_group_name is not None:
                self._values["source_security_group_name"] = source_security_group_name
            if source_security_group_owner_id is not None:
                self._values["source_security_group_owner_id"] = source_security_group_owner_id
            if to_port is not None:
                self._values["to_port"] = to_port

        @builtins.property
        def ip_protocol(self) -> builtins.str:
            '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).

            Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-ipprotocol
            '''
            result = self._values.get("ip_protocol")
            assert result is not None, "Required property 'ip_protocol' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def cidr_ip(self) -> typing.Optional[builtins.str]:
            '''The IPv4 address range, in CIDR format.

            You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-cidrip
            '''
            result = self._values.get("cidr_ip")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cidr_ipv6(self) -> typing.Optional[builtins.str]:
            '''The IPv6 address range, in CIDR format.

            You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

            For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-cidripv6
            '''
            result = self._values.get("cidr_ipv6")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''Updates the description of an ingress (inbound) security group rule.

            You can replace an existing description, or add a description to a rule that did not have one previously.

            Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def from_port(self) -> typing.Optional[jsii.Number]:
            '''If the protocol is TCP or UDP, this is the start of the port range.

            If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-fromport
            '''
            result = self._values.get("from_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def source_prefix_list_id(self) -> typing.Optional[builtins.str]:
            '''The ID of a prefix list.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-sourceprefixlistid
            '''
            result = self._values.get("source_prefix_list_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_security_group_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the security group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-sourcesecuritygroupid
            '''
            result = self._values.get("source_security_group_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_security_group_name(self) -> typing.Optional[builtins.str]:
            '''[Default VPC] The name of the source security group.

            You must specify either the security group ID or the security group name. You can't specify the group name in combination with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access.

            For security groups in a nondefault VPC, you must specify the group ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-sourcesecuritygroupname
            '''
            result = self._values.get("source_security_group_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def source_security_group_owner_id(self) -> typing.Optional[builtins.str]:
            '''[nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account.

            You can't specify this property with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access.

            If you specify ``SourceSecurityGroupName`` or ``SourceSecurityGroupId`` and that security group is owned by a different account than the account creating the stack, you must specify the ``SourceSecurityGroupOwnerId`` ; otherwise, this property is optional.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-sourcesecuritygroupownerid
            '''
            result = self._values.get("source_security_group_owner_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def to_port(self) -> typing.Optional[jsii.Number]:
            '''If the protocol is TCP or UDP, this is the end of the port range.

            If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-securitygroup-ingress.html#cfn-ec2-securitygroup-ingress-toport
            '''
            result = self._values.get("to_port")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IngressProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnSecurityGroupEgress(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroupEgress",
):
    '''Adds the specified outbound (egress) rule to a security group.

    An outbound rule permits instances to send traffic to the specified IPv4 or IPv6 address range, the IP addresses that are specified by a prefix list, or the instances that are associated with a destination security group. For more information, see `Security group rules <https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html>`_ .

    You must specify exactly one of the following destinations: an IPv4 or IPv6 address range, a prefix list, or a security group. Otherwise, the stack launches successfully but the rule is not added to the security group.

    You must specify a protocol for each rule (for example, TCP). If the protocol is TCP or UDP, you must also specify a port or port range. If the protocol is ICMP or ICMPv6, you must also specify the ICMP/ICMPv6 type and code. To specify all types or all codes, use -1.

    Rule changes are propagated to instances associated with the security group as quickly as possible. However, a small delay might occur.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html
    :cloudformationResource: AWS::EC2::SecurityGroupEgress
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_security_group_egress = ec2.CfnSecurityGroupEgress(self, "MyCfnSecurityGroupEgress",
            group_id="groupId",
            ip_protocol="ipProtocol",
        
            # the properties below are optional
            cidr_ip="cidrIp",
            cidr_ipv6="cidrIpv6",
            description="description",
            destination_prefix_list_id="destinationPrefixListId",
            destination_security_group_id="destinationSecurityGroupId",
            from_port=123,
            to_port=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        group_id: builtins.str,
        ip_protocol: builtins.str,
        cidr_ip: typing.Optional[builtins.str] = None,
        cidr_ipv6: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        destination_prefix_list_id: typing.Optional[builtins.str] = None,
        destination_security_group_id: typing.Optional[builtins.str] = None,
        from_port: typing.Optional[jsii.Number] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param group_id: The ID of the security group. You must specify either the security group ID or the security group name in the request. For security groups in a nondefault VPC, you must specify the security group ID.
        :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
        :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param description: The description of an egress (outbound) security group rule. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
        :param destination_prefix_list_id: The prefix list IDs for an AWS service. This is the AWS service that you want to access through a VPC endpoint from instances associated with the security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
        :param destination_security_group_id: The ID of the security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
        :param from_port: If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).
        :param to_port: If the protocol is TCP or UDP, this is the end of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c15a8a6cb1de72d8389f735b2b19fdd74abd3660cdd4ae643b096e83ad96f15d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSecurityGroupEgressProps(
            group_id=group_id,
            ip_protocol=ip_protocol,
            cidr_ip=cidr_ip,
            cidr_ipv6=cidr_ipv6,
            description=description,
            destination_prefix_list_id=destination_prefix_list_id,
            destination_security_group_id=destination_security_group_id,
            from_port=from_port,
            to_port=to_port,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0710ec20f8067c2d668b2e2bdfa5122af55b09124e593a4a92edb1e4492b196)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__17caff347875838ac5036aa298e542710f531c84f731ed8356dafacc9b178213)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The Security Group Rule Id.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="groupId")
    def group_id(self) -> builtins.str:
        '''The ID of the security group.'''
        return typing.cast(builtins.str, jsii.get(self, "groupId"))

    @group_id.setter
    def group_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6dd026961f5d12b1303998367f7c3b149ef05ede270fe566f64642ead49bf298)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupId", value)

    @builtins.property
    @jsii.member(jsii_name="ipProtocol")
    def ip_protocol(self) -> builtins.str:
        '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).'''
        return typing.cast(builtins.str, jsii.get(self, "ipProtocol"))

    @ip_protocol.setter
    def ip_protocol(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08eae465a8bf866a3aaa79efc2f702fe807f4afa34cb02269c0c58b015f1a294)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipProtocol", value)

    @builtins.property
    @jsii.member(jsii_name="cidrIp")
    def cidr_ip(self) -> typing.Optional[builtins.str]:
        '''The IPv4 address range, in CIDR format.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrIp"))

    @cidr_ip.setter
    def cidr_ip(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b69875fda44676a82ce37788aad70defb56617b0c1d6d63d8e080525dbe08906)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrIp", value)

    @builtins.property
    @jsii.member(jsii_name="cidrIpv6")
    def cidr_ipv6(self) -> typing.Optional[builtins.str]:
        '''The IPv6 address range, in CIDR format.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrIpv6"))

    @cidr_ipv6.setter
    def cidr_ipv6(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b156e438fb00a55c71c70d77360979375bb3c148566f31dd380ba7fdba0da96e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrIpv6", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of an egress (outbound) security group rule.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__078894fefea681a837f5bca96689a387e5d72cd4b49a6f4d9bad3dd092a7535c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="destinationPrefixListId")
    def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The prefix list IDs for an AWS service.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationPrefixListId"))

    @destination_prefix_list_id.setter
    def destination_prefix_list_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d794e565aa4cc41d252dd3c053188ac46b954545c0941f9045fd7d6df3e37c80)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationPrefixListId", value)

    @builtins.property
    @jsii.member(jsii_name="destinationSecurityGroupId")
    def destination_security_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationSecurityGroupId"))

    @destination_security_group_id.setter
    def destination_security_group_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a67fb1b21738daa80841f7c9adc5714d151c35110346e73a66f1ecc9040089a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationSecurityGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="fromPort")
    def from_port(self) -> typing.Optional[jsii.Number]:
        '''If the protocol is TCP or UDP, this is the start of the port range.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "fromPort"))

    @from_port.setter
    def from_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5af4fd65ecd7e49e99f253851ed8fba2f9dc8426e8b1c0dbfea72697d038f986)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "fromPort", value)

    @builtins.property
    @jsii.member(jsii_name="toPort")
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''If the protocol is TCP or UDP, this is the end of the port range.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "toPort"))

    @to_port.setter
    def to_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fa4cf3aa336f687505ca75fa71c749bbde6e65bdf3c04bf4137674763b9cd71f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toPort", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroupEgressProps",
    jsii_struct_bases=[],
    name_mapping={
        "group_id": "groupId",
        "ip_protocol": "ipProtocol",
        "cidr_ip": "cidrIp",
        "cidr_ipv6": "cidrIpv6",
        "description": "description",
        "destination_prefix_list_id": "destinationPrefixListId",
        "destination_security_group_id": "destinationSecurityGroupId",
        "from_port": "fromPort",
        "to_port": "toPort",
    },
)
class CfnSecurityGroupEgressProps:
    def __init__(
        self,
        *,
        group_id: builtins.str,
        ip_protocol: builtins.str,
        cidr_ip: typing.Optional[builtins.str] = None,
        cidr_ipv6: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        destination_prefix_list_id: typing.Optional[builtins.str] = None,
        destination_security_group_id: typing.Optional[builtins.str] = None,
        from_port: typing.Optional[jsii.Number] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnSecurityGroupEgress``.

        :param group_id: The ID of the security group. You must specify either the security group ID or the security group name in the request. For security groups in a nondefault VPC, you must specify the security group ID.
        :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
        :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param description: The description of an egress (outbound) security group rule. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
        :param destination_prefix_list_id: The prefix list IDs for an AWS service. This is the AWS service that you want to access through a VPC endpoint from instances associated with the security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
        :param destination_security_group_id: The ID of the security group. You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).
        :param from_port: If the protocol is TCP or UDP, this is the start of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).
        :param to_port: If the protocol is TCP or UDP, this is the end of the port range. If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_security_group_egress_props = ec2.CfnSecurityGroupEgressProps(
                group_id="groupId",
                ip_protocol="ipProtocol",
            
                # the properties below are optional
                cidr_ip="cidrIp",
                cidr_ipv6="cidrIpv6",
                description="description",
                destination_prefix_list_id="destinationPrefixListId",
                destination_security_group_id="destinationSecurityGroupId",
                from_port=123,
                to_port=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d33f1a1fd42aeda5693443b41a05760d7d754588b339339e6af41df9f15afb04)
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
            check_type(argname="argument ip_protocol", value=ip_protocol, expected_type=type_hints["ip_protocol"])
            check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
            check_type(argname="argument cidr_ipv6", value=cidr_ipv6, expected_type=type_hints["cidr_ipv6"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument destination_prefix_list_id", value=destination_prefix_list_id, expected_type=type_hints["destination_prefix_list_id"])
            check_type(argname="argument destination_security_group_id", value=destination_security_group_id, expected_type=type_hints["destination_security_group_id"])
            check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
            check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "group_id": group_id,
            "ip_protocol": ip_protocol,
        }
        if cidr_ip is not None:
            self._values["cidr_ip"] = cidr_ip
        if cidr_ipv6 is not None:
            self._values["cidr_ipv6"] = cidr_ipv6
        if description is not None:
            self._values["description"] = description
        if destination_prefix_list_id is not None:
            self._values["destination_prefix_list_id"] = destination_prefix_list_id
        if destination_security_group_id is not None:
            self._values["destination_security_group_id"] = destination_security_group_id
        if from_port is not None:
            self._values["from_port"] = from_port
        if to_port is not None:
            self._values["to_port"] = to_port

    @builtins.property
    def group_id(self) -> builtins.str:
        '''The ID of the security group.

        You must specify either the security group ID or the security group name in the request. For security groups in a nondefault VPC, you must specify the security group ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-groupid
        '''
        result = self._values.get("group_id")
        assert result is not None, "Required property 'group_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ip_protocol(self) -> builtins.str:
        '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).

        Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-ipprotocol
        '''
        result = self._values.get("ip_protocol")
        assert result is not None, "Required property 'ip_protocol' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr_ip(self) -> typing.Optional[builtins.str]:
        '''The IPv4 address range, in CIDR format.

        You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-cidrip
        '''
        result = self._values.get("cidr_ip")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cidr_ipv6(self) -> typing.Optional[builtins.str]:
        '''The IPv6 address range, in CIDR format.

        You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-cidripv6
        '''
        result = self._values.get("cidr_ipv6")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of an egress (outbound) security group rule.

        Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The prefix list IDs for an AWS service.

        This is the AWS service that you want to access through a VPC endpoint from instances associated with the security group.

        You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-destinationprefixlistid
        '''
        result = self._values.get("destination_prefix_list_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_security_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.

        You must specify a destination security group ( ``DestinationPrefixListId`` or ``DestinationSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-destinationsecuritygroupid
        '''
        result = self._values.get("destination_security_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def from_port(self) -> typing.Optional[jsii.Number]:
        '''If the protocol is TCP or UDP, this is the start of the port range.

        If the protocol is ICMP or ICMPv6, this is the ICMP type or -1 (all ICMP types).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-fromport
        '''
        result = self._values.get("from_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''If the protocol is TCP or UDP, this is the end of the port range.

        If the protocol is ICMP or ICMPv6, this is the ICMP code or -1 (all ICMP codes). If the start port is -1 (all ICMP types), then the end port must be -1 (all ICMP codes).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupegress.html#cfn-ec2-securitygroupegress-toport
        '''
        result = self._values.get("to_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSecurityGroupEgressProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnSecurityGroupIngress(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroupIngress",
):
    '''Adds an inbound (ingress) rule to a security group.

    An inbound rule permits instances to receive traffic from the specified IPv4 or IPv6 address range, the IP addresses that are specified by a prefix list, or the instances that are associated with a source security group. For more information, see `Security group rules <https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html>`_ .

    You must specify only one of the following sources: an IPv4 or IPv6 address range, a prefix list, or a security group. Otherwise, the stack launches successfully, but the rule is not added to the security group.

    You must specify a protocol for each rule (for example, TCP). If the protocol is TCP or UDP, you must also specify a port or port range. If the protocol is ICMP or ICMPv6, you must also specify the ICMP/ICMPv6 type and code.

    Rule changes are propagated to instances associated with the security group as quickly as possible. However, a small delay might occur.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html
    :cloudformationResource: AWS::EC2::SecurityGroupIngress
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_security_group_ingress = ec2.CfnSecurityGroupIngress(self, "MyCfnSecurityGroupIngress",
            ip_protocol="ipProtocol",
        
            # the properties below are optional
            cidr_ip="cidrIp",
            cidr_ipv6="cidrIpv6",
            description="description",
            from_port=123,
            group_id="groupId",
            group_name="groupName",
            source_prefix_list_id="sourcePrefixListId",
            source_security_group_id="sourceSecurityGroupId",
            source_security_group_name="sourceSecurityGroupName",
            source_security_group_owner_id="sourceSecurityGroupOwnerId",
            to_port=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        ip_protocol: builtins.str,
        cidr_ip: typing.Optional[builtins.str] = None,
        cidr_ipv6: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        from_port: typing.Optional[jsii.Number] = None,
        group_id: typing.Optional[builtins.str] = None,
        group_name: typing.Optional[builtins.str] = None,
        source_prefix_list_id: typing.Optional[builtins.str] = None,
        source_security_group_id: typing.Optional[builtins.str] = None,
        source_security_group_name: typing.Optional[builtins.str] = None,
        source_security_group_owner_id: typing.Optional[builtins.str] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
        :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param description: Updates the description of an ingress (inbound) security group rule. You can replace an existing description, or add a description to a rule that did not have one previously. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
        :param from_port: The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type number. A value of ``-1`` indicates all ICMP/ICMPv6 types. If you specify all ICMP/ICMPv6 types, you must specify all codes. Use this for ICMP and any protocol that uses ports.
        :param group_id: The ID of the security group.
        :param group_name: The name of the security group. Constraints: Up to 255 characters in length. Cannot start with ``sg-`` . Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param source_prefix_list_id: The ID of a prefix list.
        :param source_security_group_id: The ID of the security group. You must specify either the security group ID or the security group name. For security groups in a nondefault VPC, you must specify the security group ID.
        :param source_security_group_name: [Default VPC] The name of the source security group. You must specify either the security group ID or the security group name. You can't specify the group name in combination with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. For security groups in a nondefault VPC, you must specify the group ID.
        :param source_security_group_owner_id: [nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account. You can't specify this property with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. If you specify ``SourceSecurityGroupName`` or ``SourceSecurityGroupId`` and that security group is owned by a different account than the account creating the stack, you must specify ``SourceSecurityGroupOwnerId`` ; otherwise, this property is optional.
        :param to_port: The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code. A value of ``-1`` indicates all ICMP/ICMPv6 codes for the specified ICMP type. If you specify all ICMP/ICMPv6 types, you must specify all codes. Use this for ICMP and any protocol that uses ports.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__99cf71ba90fdd23ce4fa6a965bf9e8cb57a3209fe7de8914f15c94b67e357708)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSecurityGroupIngressProps(
            ip_protocol=ip_protocol,
            cidr_ip=cidr_ip,
            cidr_ipv6=cidr_ipv6,
            description=description,
            from_port=from_port,
            group_id=group_id,
            group_name=group_name,
            source_prefix_list_id=source_prefix_list_id,
            source_security_group_id=source_security_group_id,
            source_security_group_name=source_security_group_name,
            source_security_group_owner_id=source_security_group_owner_id,
            to_port=to_port,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51183013e439efce6ac8bedbc4bfb686a5d94f9530b28cf72a834b681ff6a6b0)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__26028434fdb84281d551c700d34142ca5185c12eb87fc76d4e22d061aee3a441)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The Security Group Rule Id.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="ipProtocol")
    def ip_protocol(self) -> builtins.str:
        '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).'''
        return typing.cast(builtins.str, jsii.get(self, "ipProtocol"))

    @ip_protocol.setter
    def ip_protocol(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0fb423251dd58c8eba6fd66411dd947a25c70ae1162c5d8f4d45e7df38b09670)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipProtocol", value)

    @builtins.property
    @jsii.member(jsii_name="cidrIp")
    def cidr_ip(self) -> typing.Optional[builtins.str]:
        '''The IPv4 address range, in CIDR format.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrIp"))

    @cidr_ip.setter
    def cidr_ip(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85ee28d6bc44c94e0cd7644a5ef96652bbef3b8bc5f79067580a31cdc44922ae)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrIp", value)

    @builtins.property
    @jsii.member(jsii_name="cidrIpv6")
    def cidr_ipv6(self) -> typing.Optional[builtins.str]:
        '''The IPv6 address range, in CIDR format.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrIpv6"))

    @cidr_ipv6.setter
    def cidr_ipv6(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__752a27a824e6a4b39f735f987c2e8812ffe675605408a151aa5aefe7b2a4c698)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrIpv6", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''Updates the description of an ingress (inbound) security group rule.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e23627da1e141f44c0850f243dc525319bd08080d3c5a976ba721e6b0aa9a6bb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="fromPort")
    def from_port(self) -> typing.Optional[jsii.Number]:
        '''The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type number.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "fromPort"))

    @from_port.setter
    def from_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39e16b8ebb7d71b585aa6910df1a93f1dc36d419ee3bdc5f8f5d1e8cf8b18014)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "fromPort", value)

    @builtins.property
    @jsii.member(jsii_name="groupId")
    def group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "groupId"))

    @group_id.setter
    def group_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__338c8ff9c804245c7a3e32a4540ff5a8252c81b08d80182f0b2de5d40434c69a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupId", value)

    @builtins.property
    @jsii.member(jsii_name="groupName")
    def group_name(self) -> typing.Optional[builtins.str]:
        '''The name of the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "groupName"))

    @group_name.setter
    def group_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c75160a31adb01e7ec3b8f1d1d263e2fd14e716f202cb36412d72885e45a74b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupName", value)

    @builtins.property
    @jsii.member(jsii_name="sourcePrefixListId")
    def source_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a prefix list.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourcePrefixListId"))

    @source_prefix_list_id.setter
    def source_prefix_list_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c110b093f13dc2ce5d12b8b8f73d53b092cd966ae2de4f5bd5054e6824056269)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourcePrefixListId", value)

    @builtins.property
    @jsii.member(jsii_name="sourceSecurityGroupId")
    def source_security_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourceSecurityGroupId"))

    @source_security_group_id.setter
    def source_security_group_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2472cce371b656bb65ca0993578ff7a45d796afb07a89e30393a2975942cc331)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceSecurityGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="sourceSecurityGroupName")
    def source_security_group_name(self) -> typing.Optional[builtins.str]:
        '''[Default VPC] The name of the source security group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourceSecurityGroupName"))

    @source_security_group_name.setter
    def source_security_group_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c4395f9fe936ca2f0ef917f77b0c90bab4b67f95e5808c4214967d4301ef8aa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceSecurityGroupName", value)

    @builtins.property
    @jsii.member(jsii_name="sourceSecurityGroupOwnerId")
    def source_security_group_owner_id(self) -> typing.Optional[builtins.str]:
        '''[nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "sourceSecurityGroupOwnerId"))

    @source_security_group_owner_id.setter
    def source_security_group_owner_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2cf91ed7b67973212326d76bc04e1b4c178b69d92329ab670078072e27757cd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceSecurityGroupOwnerId", value)

    @builtins.property
    @jsii.member(jsii_name="toPort")
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "toPort"))

    @to_port.setter
    def to_port(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14c1913a7e3440114741b0331b2106db513750734db62f32370f04806f56e1b5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toPort", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroupIngressProps",
    jsii_struct_bases=[],
    name_mapping={
        "ip_protocol": "ipProtocol",
        "cidr_ip": "cidrIp",
        "cidr_ipv6": "cidrIpv6",
        "description": "description",
        "from_port": "fromPort",
        "group_id": "groupId",
        "group_name": "groupName",
        "source_prefix_list_id": "sourcePrefixListId",
        "source_security_group_id": "sourceSecurityGroupId",
        "source_security_group_name": "sourceSecurityGroupName",
        "source_security_group_owner_id": "sourceSecurityGroupOwnerId",
        "to_port": "toPort",
    },
)
class CfnSecurityGroupIngressProps:
    def __init__(
        self,
        *,
        ip_protocol: builtins.str,
        cidr_ip: typing.Optional[builtins.str] = None,
        cidr_ipv6: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        from_port: typing.Optional[jsii.Number] = None,
        group_id: typing.Optional[builtins.str] = None,
        group_name: typing.Optional[builtins.str] = None,
        source_prefix_list_id: typing.Optional[builtins.str] = None,
        source_security_group_id: typing.Optional[builtins.str] = None,
        source_security_group_name: typing.Optional[builtins.str] = None,
        source_security_group_owner_id: typing.Optional[builtins.str] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnSecurityGroupIngress``.

        :param ip_protocol: The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ). Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.
        :param cidr_ip: The IPv4 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param cidr_ipv6: The IPv6 address range, in CIDR format. You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ). For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .
        :param description: Updates the description of an ingress (inbound) security group rule. You can replace an existing description, or add a description to a rule that did not have one previously. Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*
        :param from_port: The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type number. A value of ``-1`` indicates all ICMP/ICMPv6 types. If you specify all ICMP/ICMPv6 types, you must specify all codes. Use this for ICMP and any protocol that uses ports.
        :param group_id: The ID of the security group.
        :param group_name: The name of the security group. Constraints: Up to 255 characters in length. Cannot start with ``sg-`` . Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param source_prefix_list_id: The ID of a prefix list.
        :param source_security_group_id: The ID of the security group. You must specify either the security group ID or the security group name. For security groups in a nondefault VPC, you must specify the security group ID.
        :param source_security_group_name: [Default VPC] The name of the source security group. You must specify either the security group ID or the security group name. You can't specify the group name in combination with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. For security groups in a nondefault VPC, you must specify the group ID.
        :param source_security_group_owner_id: [nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account. You can't specify this property with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access. If you specify ``SourceSecurityGroupName`` or ``SourceSecurityGroupId`` and that security group is owned by a different account than the account creating the stack, you must specify ``SourceSecurityGroupOwnerId`` ; otherwise, this property is optional.
        :param to_port: The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code. A value of ``-1`` indicates all ICMP/ICMPv6 codes for the specified ICMP type. If you specify all ICMP/ICMPv6 types, you must specify all codes. Use this for ICMP and any protocol that uses ports.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_security_group_ingress_props = ec2.CfnSecurityGroupIngressProps(
                ip_protocol="ipProtocol",
            
                # the properties below are optional
                cidr_ip="cidrIp",
                cidr_ipv6="cidrIpv6",
                description="description",
                from_port=123,
                group_id="groupId",
                group_name="groupName",
                source_prefix_list_id="sourcePrefixListId",
                source_security_group_id="sourceSecurityGroupId",
                source_security_group_name="sourceSecurityGroupName",
                source_security_group_owner_id="sourceSecurityGroupOwnerId",
                to_port=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9577309b12889b3c94a45de262d0695890476aaeb9f9797887f45c0f9c6a59ca)
            check_type(argname="argument ip_protocol", value=ip_protocol, expected_type=type_hints["ip_protocol"])
            check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
            check_type(argname="argument cidr_ipv6", value=cidr_ipv6, expected_type=type_hints["cidr_ipv6"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
            check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
            check_type(argname="argument source_prefix_list_id", value=source_prefix_list_id, expected_type=type_hints["source_prefix_list_id"])
            check_type(argname="argument source_security_group_id", value=source_security_group_id, expected_type=type_hints["source_security_group_id"])
            check_type(argname="argument source_security_group_name", value=source_security_group_name, expected_type=type_hints["source_security_group_name"])
            check_type(argname="argument source_security_group_owner_id", value=source_security_group_owner_id, expected_type=type_hints["source_security_group_owner_id"])
            check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ip_protocol": ip_protocol,
        }
        if cidr_ip is not None:
            self._values["cidr_ip"] = cidr_ip
        if cidr_ipv6 is not None:
            self._values["cidr_ipv6"] = cidr_ipv6
        if description is not None:
            self._values["description"] = description
        if from_port is not None:
            self._values["from_port"] = from_port
        if group_id is not None:
            self._values["group_id"] = group_id
        if group_name is not None:
            self._values["group_name"] = group_name
        if source_prefix_list_id is not None:
            self._values["source_prefix_list_id"] = source_prefix_list_id
        if source_security_group_id is not None:
            self._values["source_security_group_id"] = source_security_group_id
        if source_security_group_name is not None:
            self._values["source_security_group_name"] = source_security_group_name
        if source_security_group_owner_id is not None:
            self._values["source_security_group_owner_id"] = source_security_group_owner_id
        if to_port is not None:
            self._values["to_port"] = to_port

    @builtins.property
    def ip_protocol(self) -> builtins.str:
        '''The IP protocol name ( ``tcp`` , ``udp`` , ``icmp`` , ``icmpv6`` ) or number (see `Protocol Numbers <https://docs.aws.amazon.com/http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ ).

        Use ``-1`` to specify all protocols. When authorizing security group rules, specifying ``-1`` or a protocol number other than ``tcp`` , ``udp`` , ``icmp`` , or ``icmpv6`` allows traffic on all ports, regardless of any port range you specify. For ``tcp`` , ``udp`` , and ``icmp`` , you must specify a port range. For ``icmpv6`` , the port range is optional; if you omit the port range, traffic for all types and codes is allowed.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-ipprotocol
        '''
        result = self._values.get("ip_protocol")
        assert result is not None, "Required property 'ip_protocol' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr_ip(self) -> typing.Optional[builtins.str]:
        '''The IPv4 address range, in CIDR format.

        You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-cidrip
        '''
        result = self._values.get("cidr_ip")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cidr_ipv6(self) -> typing.Optional[builtins.str]:
        '''The IPv6 address range, in CIDR format.

        You must specify a source security group ( ``SourcePrefixListId`` or ``SourceSecurityGroupId`` ) or a CIDR range ( ``CidrIp`` or ``CidrIpv6`` ).

        For examples of rules that you can add to security groups for specific access scenarios, see `Security group rules for different use cases <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html>`_ in the *Amazon EC2 User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-cidripv6
        '''
        result = self._values.get("cidr_ipv6")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''Updates the description of an ingress (inbound) security group rule.

        You can replace an existing description, or add a description to a rule that did not have one previously.

        Constraints: Up to 255 characters in length. Allowed characters are a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=;{}!$*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def from_port(self) -> typing.Optional[jsii.Number]:
        '''The start of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 type number.

        A value of ``-1`` indicates all ICMP/ICMPv6 types. If you specify all ICMP/ICMPv6 types, you must specify all codes.

        Use this for ICMP and any protocol that uses ports.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-fromport
        '''
        result = self._values.get("from_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-groupid
        '''
        result = self._values.get("group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def group_name(self) -> typing.Optional[builtins.str]:
        '''The name of the security group.

        Constraints: Up to 255 characters in length. Cannot start with ``sg-`` .

        Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-groupname
        '''
        result = self._values.get("group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_prefix_list_id(self) -> typing.Optional[builtins.str]:
        '''The ID of a prefix list.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-sourceprefixlistid
        '''
        result = self._values.get("source_prefix_list_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_security_group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the security group.

        You must specify either the security group ID or the security group name. For security groups in a nondefault VPC, you must specify the security group ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-sourcesecuritygroupid
        '''
        result = self._values.get("source_security_group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_security_group_name(self) -> typing.Optional[builtins.str]:
        '''[Default VPC] The name of the source security group.

        You must specify either the security group ID or the security group name. You can't specify the group name in combination with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access.

        For security groups in a nondefault VPC, you must specify the group ID.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-sourcesecuritygroupname
        '''
        result = self._values.get("source_security_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def source_security_group_owner_id(self) -> typing.Optional[builtins.str]:
        '''[nondefault VPC] The AWS account ID for the source security group, if the source security group is in a different account.

        You can't specify this property with an IP address range. Creates rules that grant full ICMP, UDP, and TCP access.

        If you specify ``SourceSecurityGroupName`` or ``SourceSecurityGroupId`` and that security group is owned by a different account than the account creating the stack, you must specify ``SourceSecurityGroupOwnerId`` ; otherwise, this property is optional.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-sourcesecuritygroupownerid
        '''
        result = self._values.get("source_security_group_owner_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''The end of port range for the TCP and UDP protocols, or an ICMP/ICMPv6 code.

        A value of ``-1`` indicates all ICMP/ICMPv6 codes for the specified ICMP type. If you specify all ICMP/ICMPv6 types, you must specify all codes.

        Use this for ICMP and any protocol that uses ports.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroupingress.html#cfn-ec2-securitygroupingress-toport
        '''
        result = self._values.get("to_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSecurityGroupIngressProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSecurityGroupProps",
    jsii_struct_bases=[],
    name_mapping={
        "group_description": "groupDescription",
        "group_name": "groupName",
        "security_group_egress": "securityGroupEgress",
        "security_group_ingress": "securityGroupIngress",
        "tags": "tags",
        "vpc_id": "vpcId",
    },
)
class CfnSecurityGroupProps:
    def __init__(
        self,
        *,
        group_description: builtins.str,
        group_name: typing.Optional[builtins.str] = None,
        security_group_egress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.EgressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        security_group_ingress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.IngressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnSecurityGroup``.

        :param group_description: A description for the security group. Constraints: Up to 255 characters in length Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param group_name: The name of the security group. Constraints: Up to 255 characters in length. Cannot start with ``sg-`` . Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*
        :param security_group_egress: The outbound rules associated with the security group. There is a short interruption during which you cannot connect to the security group.
        :param security_group_ingress: The inbound rules associated with the security group. There is a short interruption during which you cannot connect to the security group.
        :param tags: Any tags assigned to the security group.
        :param vpc_id: The ID of the VPC for the security group. If you do not specify a VPC, the default is to use the default VPC for the Region. If there's no specified VPC and no default VPC, security group creation fails.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_security_group_props = ec2.CfnSecurityGroupProps(
                group_description="groupDescription",
            
                # the properties below are optional
                group_name="groupName",
                security_group_egress=[ec2.CfnSecurityGroup.EgressProperty(
                    ip_protocol="ipProtocol",
            
                    # the properties below are optional
                    cidr_ip="cidrIp",
                    cidr_ipv6="cidrIpv6",
                    description="description",
                    destination_prefix_list_id="destinationPrefixListId",
                    destination_security_group_id="destinationSecurityGroupId",
                    from_port=123,
                    to_port=123
                )],
                security_group_ingress=[ec2.CfnSecurityGroup.IngressProperty(
                    ip_protocol="ipProtocol",
            
                    # the properties below are optional
                    cidr_ip="cidrIp",
                    cidr_ipv6="cidrIpv6",
                    description="description",
                    from_port=123,
                    source_prefix_list_id="sourcePrefixListId",
                    source_security_group_id="sourceSecurityGroupId",
                    source_security_group_name="sourceSecurityGroupName",
                    source_security_group_owner_id="sourceSecurityGroupOwnerId",
                    to_port=123
                )],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                vpc_id="vpcId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a21c9d7bd7156fd2dd5a288945bbf548f4ab7a9ee07ba36ecb2062ab615ce325)
            check_type(argname="argument group_description", value=group_description, expected_type=type_hints["group_description"])
            check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
            check_type(argname="argument security_group_egress", value=security_group_egress, expected_type=type_hints["security_group_egress"])
            check_type(argname="argument security_group_ingress", value=security_group_ingress, expected_type=type_hints["security_group_ingress"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "group_description": group_description,
        }
        if group_name is not None:
            self._values["group_name"] = group_name
        if security_group_egress is not None:
            self._values["security_group_egress"] = security_group_egress
        if security_group_ingress is not None:
            self._values["security_group_ingress"] = security_group_ingress
        if tags is not None:
            self._values["tags"] = tags
        if vpc_id is not None:
            self._values["vpc_id"] = vpc_id

    @builtins.property
    def group_description(self) -> builtins.str:
        '''A description for the security group.

        Constraints: Up to 255 characters in length

        Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-groupdescription
        '''
        result = self._values.get("group_description")
        assert result is not None, "Required property 'group_description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def group_name(self) -> typing.Optional[builtins.str]:
        '''The name of the security group.

        Constraints: Up to 255 characters in length. Cannot start with ``sg-`` .

        Valid characters: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$*

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-groupname
        '''
        result = self._values.get("group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def security_group_egress(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.EgressProperty]]]]:
        '''The outbound rules associated with the security group.

        There is a short interruption during which you cannot connect to the security group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-securitygroupegress
        '''
        result = self._values.get("security_group_egress")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.EgressProperty]]]], result)

    @builtins.property
    def security_group_ingress(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.IngressProperty]]]]:
        '''The inbound rules associated with the security group.

        There is a short interruption during which you cannot connect to the security group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-securitygroupingress
        '''
        result = self._values.get("security_group_ingress")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.IngressProperty]]]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the security group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def vpc_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the VPC for the security group.

        If you do not specify a VPC, the default is to use the default VPC for the Region. If there's no specified VPC and no default VPC, security group creation fails.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-securitygroup.html#cfn-ec2-securitygroup-vpcid
        '''
        result = self._values.get("vpc_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSecurityGroupProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnSnapshotBlockPublicAccess(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSnapshotBlockPublicAccess",
):
    '''Specifies the state of the *block public access for snapshots* setting for the Region.

    For more information, see `Block public access for snapshots <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-snapshots.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-snapshotblockpublicaccess.html
    :cloudformationResource: AWS::EC2::SnapshotBlockPublicAccess
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_snapshot_block_public_access = ec2.CfnSnapshotBlockPublicAccess(self, "MyCfnSnapshotBlockPublicAccess",
            state="state"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        state: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param state: The mode in which to enable block public access for snapshots for the Region. Specify one of the following values: - ``block-all-sharing`` - Prevents all public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. Additionally, snapshots that are already publicly shared are treated as private and they are no longer publicly available. .. epigraph:: If you enable block public access for snapshots in ``block-all-sharing`` mode, it does not change the permissions for snapshots that are already publicly shared. Instead, it prevents these snapshots from be publicly visible and publicly accessible. Therefore, the attributes for these snapshots still indicate that they are publicly shared, even though they are not publicly available. - ``block-new-sharing`` - Prevents only new public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. However, snapshots that are already publicly shared, remain publicly available.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__995a1a5869d618c24a624831b2ad5e725b73ab6134ba003d66411c58faf1187e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSnapshotBlockPublicAccessProps(state=state)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__856438104299447428cd955093ead73bce11b3f11c039205bcd5e194beb9b322)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5986589d73c46b7a96fd8cdffc5dd783512e594c0f96cf249a7577ed130d1c96)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAccountId")
    def attr_account_id(self) -> builtins.str:
        '''``Ref`` returns the ID of the AWS account.

        :cloudformationAttribute: AccountId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAccountId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="state")
    def state(self) -> builtins.str:
        '''The mode in which to enable block public access for snapshots for the Region.'''
        return typing.cast(builtins.str, jsii.get(self, "state"))

    @state.setter
    def state(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a4c8cd7c082b41fda937b1f6a6a1a59e489b437d498c2b75a58ae1582086af7b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "state", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSnapshotBlockPublicAccessProps",
    jsii_struct_bases=[],
    name_mapping={"state": "state"},
)
class CfnSnapshotBlockPublicAccessProps:
    def __init__(self, *, state: builtins.str) -> None:
        '''Properties for defining a ``CfnSnapshotBlockPublicAccess``.

        :param state: The mode in which to enable block public access for snapshots for the Region. Specify one of the following values: - ``block-all-sharing`` - Prevents all public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. Additionally, snapshots that are already publicly shared are treated as private and they are no longer publicly available. .. epigraph:: If you enable block public access for snapshots in ``block-all-sharing`` mode, it does not change the permissions for snapshots that are already publicly shared. Instead, it prevents these snapshots from be publicly visible and publicly accessible. Therefore, the attributes for these snapshots still indicate that they are publicly shared, even though they are not publicly available. - ``block-new-sharing`` - Prevents only new public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. However, snapshots that are already publicly shared, remain publicly available.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-snapshotblockpublicaccess.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_snapshot_block_public_access_props = ec2.CfnSnapshotBlockPublicAccessProps(
                state="state"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e66d65de803363af49ef406b4229988fd2680cccdc692b106aff40a80ff135ad)
            check_type(argname="argument state", value=state, expected_type=type_hints["state"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "state": state,
        }

    @builtins.property
    def state(self) -> builtins.str:
        '''The mode in which to enable block public access for snapshots for the Region.

        Specify one of the following values:

        - ``block-all-sharing`` - Prevents all public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. Additionally, snapshots that are already publicly shared are treated as private and they are no longer publicly available.

        .. epigraph::

           If you enable block public access for snapshots in ``block-all-sharing`` mode, it does not change the permissions for snapshots that are already publicly shared. Instead, it prevents these snapshots from be publicly visible and publicly accessible. Therefore, the attributes for these snapshots still indicate that they are publicly shared, even though they are not publicly available.

        - ``block-new-sharing`` - Prevents only new public sharing of snapshots in the Region. Users in the account will no longer be able to request new public sharing. However, snapshots that are already publicly shared, remain publicly available.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-snapshotblockpublicaccess.html#cfn-ec2-snapshotblockpublicaccess-state
        '''
        result = self._values.get("state")
        assert result is not None, "Required property 'state' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSnapshotBlockPublicAccessProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnSpotFleet(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet",
):
    '''Specifies a Spot Fleet request.

    The Spot Fleet request specifies the total target capacity and the On-Demand target capacity. Amazon EC2 calculates the difference between the total capacity and On-Demand capacity, and launches the difference as Spot capacity.

    You can submit a single request that includes multiple launch specifications that vary by instance type, AMI, Availability Zone, or subnet.

    By default, the Spot Fleet requests Spot Instances in the Spot Instance pool where the price per unit is the lowest. Each launch specification can include its own instance weighting that reflects the value of the instance type to your application workload.

    Alternatively, you can specify that the Spot Fleet distribute the target capacity across the Spot pools included in its launch specifications. By ensuring that the Spot Instances in your Spot Fleet are in different Spot pools, you can improve the availability of your fleet.

    You can specify tags for the Spot Fleet request and instances launched by the fleet. You cannot tag other resource types in a Spot Fleet request because only the ``spot-fleet-request`` and ``instance`` resource types are supported.

    For more information, see `Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .
    .. epigraph::

       We strongly discourage using the RequestSpotFleet API because it is a legacy API with no planned investment. For options for requesting Spot Instances, see `Which is the best Spot request method to use? <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-best-practices.html#which-spot-request-method-to-use>`_ in the *Amazon EC2 User Guide for Linux Instances* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-spotfleet.html
    :cloudformationResource: AWS::EC2::SpotFleet
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_spot_fleet = ec2.CfnSpotFleet(self, "MyCfnSpotFleet",
            spot_fleet_request_config_data=ec2.CfnSpotFleet.SpotFleetRequestConfigDataProperty(
                iam_fleet_role="iamFleetRole",
                target_capacity=123,
        
                # the properties below are optional
                allocation_strategy="allocationStrategy",
                context="context",
                excess_capacity_termination_policy="excessCapacityTerminationPolicy",
                instance_interruption_behavior="instanceInterruptionBehavior",
                instance_pools_to_use_count=123,
                launch_specifications=[ec2.CfnSpotFleet.SpotFleetLaunchSpecificationProperty(
                    image_id="imageId",
        
                    # the properties below are optional
                    block_device_mappings=[ec2.CfnSpotFleet.BlockDeviceMappingProperty(
                        device_name="deviceName",
        
                        # the properties below are optional
                        ebs=ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                            delete_on_termination=False,
                            encrypted=False,
                            iops=123,
                            snapshot_id="snapshotId",
                            volume_size=123,
                            volume_type="volumeType"
                        ),
                        no_device="noDevice",
                        virtual_name="virtualName"
                    )],
                    ebs_optimized=False,
                    iam_instance_profile=ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty(
                        arn="arn"
                    ),
                    instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                        accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    kernel_id="kernelId",
                    key_name="keyName",
                    monitoring=ec2.CfnSpotFleet.SpotFleetMonitoringProperty(
                        enabled=False
                    ),
                    network_interfaces=[ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty(
                        associate_public_ip_address=False,
                        delete_on_termination=False,
                        description="description",
                        device_index=123,
                        groups=["groups"],
                        ipv6_address_count=123,
                        ipv6_addresses=[ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                            ipv6_address="ipv6Address"
                        )],
                        network_interface_id="networkInterfaceId",
                        private_ip_addresses=[ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                            private_ip_address="privateIpAddress",
        
                            # the properties below are optional
                            primary=False
                        )],
                        secondary_private_ip_address_count=123,
                        subnet_id="subnetId"
                    )],
                    placement=ec2.CfnSpotFleet.SpotPlacementProperty(
                        availability_zone="availabilityZone",
                        group_name="groupName",
                        tenancy="tenancy"
                    ),
                    ramdisk_id="ramdiskId",
                    security_groups=[ec2.CfnSpotFleet.GroupIdentifierProperty(
                        group_id="groupId"
                    )],
                    spot_price="spotPrice",
                    subnet_id="subnetId",
                    tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                        resource_type="resourceType",
                        tags=[CfnTag(
                            key="key",
                            value="value"
                        )]
                    )],
                    user_data="userData",
                    weighted_capacity=123
                )],
                launch_template_configs=[ec2.CfnSpotFleet.LaunchTemplateConfigProperty(
                    launch_template_specification=ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty(
                        version="version",
        
                        # the properties below are optional
                        launch_template_id="launchTemplateId",
                        launch_template_name="launchTemplateName"
                    ),
                    overrides=[ec2.CfnSpotFleet.LaunchTemplateOverridesProperty(
                        availability_zone="availabilityZone",
                        instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        priority=123,
                        spot_price="spotPrice",
                        subnet_id="subnetId",
                        weighted_capacity=123
                    )]
                )],
                load_balancers_config=ec2.CfnSpotFleet.LoadBalancersConfigProperty(
                    classic_load_balancers_config=ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty(
                        classic_load_balancers=[ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                            name="name"
                        )]
                    ),
                    target_groups_config=ec2.CfnSpotFleet.TargetGroupsConfigProperty(
                        target_groups=[ec2.CfnSpotFleet.TargetGroupProperty(
                            arn="arn"
                        )]
                    )
                ),
                on_demand_allocation_strategy="onDemandAllocationStrategy",
                on_demand_max_total_price="onDemandMaxTotalPrice",
                on_demand_target_capacity=123,
                replace_unhealthy_instances=False,
                spot_maintenance_strategies=ec2.CfnSpotFleet.SpotMaintenanceStrategiesProperty(
                    capacity_rebalance=ec2.CfnSpotFleet.SpotCapacityRebalanceProperty(
                        replacement_strategy="replacementStrategy",
                        termination_delay=123
                    )
                ),
                spot_max_total_price="spotMaxTotalPrice",
                spot_price="spotPrice",
                tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )],
                target_capacity_unit_type="targetCapacityUnitType",
                terminate_instances_with_expiration=False,
                type="type",
                valid_from="validFrom",
                valid_until="validUntil"
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        spot_fleet_request_config_data: typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotFleetRequestConfigDataProperty", typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param spot_fleet_request_config_data: Describes the configuration of a Spot Fleet request.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__507ab221d4bf8e8520b22850e0df945eba1ce8da26b5b5f4800e98249ec0bb9c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSpotFleetProps(
            spot_fleet_request_config_data=spot_fleet_request_config_data
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b956e8943bfa35327db536994b6edbe089284801ca3e46a1082facfee29d79e8)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29e928bf0c0a765c31ed1aabb95ddb547b2caadb528c87b562c330345b3e0bf5)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the Spot Fleet.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="spotFleetRequestConfigData")
    def spot_fleet_request_config_data(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetRequestConfigDataProperty"]:
        '''Describes the configuration of a Spot Fleet request.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetRequestConfigDataProperty"], jsii.get(self, "spotFleetRequestConfigData"))

    @spot_fleet_request_config_data.setter
    def spot_fleet_request_config_data(
        self,
        value: typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetRequestConfigDataProperty"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9c164a161df2064007e11aa13f2fcdc69c4d526147241ddb279829db7e4c08a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "spotFleetRequestConfigData", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.AcceleratorCountRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorCountRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            :param max: The maximum number of accelerators. To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .
            :param min: The minimum number of accelerators. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratorcountrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_count_request_property = ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9450177c100960250074c89d88e9a91ffb7858df09cb594773cd480253ee8cab)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of accelerators.

            To specify no maximum limit, omit this parameter. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratorcountrequest.html#cfn-ec2-spotfleet-acceleratorcountrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of accelerators.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratorcountrequest.html#cfn-ec2-spotfleet-acceleratorcountrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorCountRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class AcceleratorTotalMemoryMiBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            :param max: The maximum amount of accelerator memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of accelerator memory, in MiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratortotalmemorymibrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                accelerator_total_memory_mi_bRequest_property = ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ad298024f0d66aef3de35bb7901254b09e0382ba2e0fba90cd0884eeec9bf9ec)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of accelerator memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratortotalmemorymibrequest.html#cfn-ec2-spotfleet-acceleratortotalmemorymibrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of accelerator memory, in MiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-acceleratortotalmemorymibrequest.html#cfn-ec2-spotfleet-acceleratortotalmemorymibrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "AcceleratorTotalMemoryMiBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class BaselineEbsBandwidthMbpsRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            :param max: The maximum baseline bandwidth, in Mbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum baseline bandwidth, in Mbps. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-baselineebsbandwidthmbpsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                baseline_ebs_bandwidth_mbps_request_property = ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9ce4579262afb56f65f3c52460d38101dc8cc8042547f0bd533d017fb03704eb)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum baseline bandwidth, in Mbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-baselineebsbandwidthmbpsrequest.html#cfn-ec2-spotfleet-baselineebsbandwidthmbpsrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum baseline bandwidth, in Mbps.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-baselineebsbandwidthmbpsrequest.html#cfn-ec2-spotfleet-baselineebsbandwidthmbpsrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BaselineEbsBandwidthMbpsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.BlockDeviceMappingProperty",
        jsii_struct_bases=[],
        name_mapping={
            "device_name": "deviceName",
            "ebs": "ebs",
            "no_device": "noDevice",
            "virtual_name": "virtualName",
        },
    )
    class BlockDeviceMappingProperty:
        def __init__(
            self,
            *,
            device_name: builtins.str,
            ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.EbsBlockDeviceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            no_device: typing.Optional[builtins.str] = None,
            virtual_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies a block device mapping.

            You can specify ``Ebs`` or ``VirtualName`` , but not both.

            :param device_name: The device name (for example, ``/dev/sdh`` or ``xvdh`` ).
            :param ebs: Parameters used to automatically set up EBS volumes when the instance is launched.
            :param no_device: To omit the device from the block device mapping, specify an empty string. When this property is specified, the device is removed from the block device mapping regardless of the assigned value.
            :param virtual_name: The virtual device name ( ``ephemeral`` N). Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume. NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect. Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-blockdevicemapping.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                block_device_mapping_property = ec2.CfnSpotFleet.BlockDeviceMappingProperty(
                    device_name="deviceName",
                
                    # the properties below are optional
                    ebs=ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                        delete_on_termination=False,
                        encrypted=False,
                        iops=123,
                        snapshot_id="snapshotId",
                        volume_size=123,
                        volume_type="volumeType"
                    ),
                    no_device="noDevice",
                    virtual_name="virtualName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__eaf57c5479d93c1d582f3d3d29acc1adcd3859e499d942b90078c476602172fd)
                check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
                check_type(argname="argument ebs", value=ebs, expected_type=type_hints["ebs"])
                check_type(argname="argument no_device", value=no_device, expected_type=type_hints["no_device"])
                check_type(argname="argument virtual_name", value=virtual_name, expected_type=type_hints["virtual_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "device_name": device_name,
            }
            if ebs is not None:
                self._values["ebs"] = ebs
            if no_device is not None:
                self._values["no_device"] = no_device
            if virtual_name is not None:
                self._values["virtual_name"] = virtual_name

        @builtins.property
        def device_name(self) -> builtins.str:
            '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-blockdevicemapping.html#cfn-ec2-spotfleet-blockdevicemapping-devicename
            '''
            result = self._values.get("device_name")
            assert result is not None, "Required property 'device_name' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def ebs(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.EbsBlockDeviceProperty"]]:
            '''Parameters used to automatically set up EBS volumes when the instance is launched.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-blockdevicemapping.html#cfn-ec2-spotfleet-blockdevicemapping-ebs
            '''
            result = self._values.get("ebs")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.EbsBlockDeviceProperty"]], result)

        @builtins.property
        def no_device(self) -> typing.Optional[builtins.str]:
            '''To omit the device from the block device mapping, specify an empty string.

            When this property is specified, the device is removed from the block device mapping regardless of the assigned value.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-blockdevicemapping.html#cfn-ec2-spotfleet-blockdevicemapping-nodevice
            '''
            result = self._values.get("no_device")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def virtual_name(self) -> typing.Optional[builtins.str]:
            '''The virtual device name ( ``ephemeral`` N).

            Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.

            NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect.

            Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-blockdevicemapping.html#cfn-ec2-spotfleet-blockdevicemapping-virtualname
            '''
            result = self._values.get("virtual_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "BlockDeviceMappingProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.ClassicLoadBalancerProperty",
        jsii_struct_bases=[],
        name_mapping={"name": "name"},
    )
    class ClassicLoadBalancerProperty:
        def __init__(self, *, name: builtins.str) -> None:
            '''Specifies a Classic Load Balancer.

            :param name: The name of the load balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-classicloadbalancer.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                classic_load_balancer_property = ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                    name="name"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ca150b39fa706ec4abd897598b47113f9d45fc9daa40116380b828426e9643f8)
                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "name": name,
            }

        @builtins.property
        def name(self) -> builtins.str:
            '''The name of the load balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-classicloadbalancer.html#cfn-ec2-spotfleet-classicloadbalancer-name
            '''
            result = self._values.get("name")
            assert result is not None, "Required property 'name' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClassicLoadBalancerProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty",
        jsii_struct_bases=[],
        name_mapping={"classic_load_balancers": "classicLoadBalancers"},
    )
    class ClassicLoadBalancersConfigProperty:
        def __init__(
            self,
            *,
            classic_load_balancers: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.ClassicLoadBalancerProperty", typing.Dict[builtins.str, typing.Any]]]]],
        ) -> None:
            '''Specifies the Classic Load Balancers to attach to a Spot Fleet.

            Spot Fleet registers the running Spot Instances with these Classic Load Balancers.

            :param classic_load_balancers: One or more Classic Load Balancers.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-classicloadbalancersconfig.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                classic_load_balancers_config_property = ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty(
                    classic_load_balancers=[ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                        name="name"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__239f11e515811c4899eaf71cbfdfae21b9e614b8afcf11b03fbbfb25f04b894f)
                check_type(argname="argument classic_load_balancers", value=classic_load_balancers, expected_type=type_hints["classic_load_balancers"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "classic_load_balancers": classic_load_balancers,
            }

        @builtins.property
        def classic_load_balancers(
            self,
        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.ClassicLoadBalancerProperty"]]]:
            '''One or more Classic Load Balancers.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-classicloadbalancersconfig.html#cfn-ec2-spotfleet-classicloadbalancersconfig-classicloadbalancers
            '''
            result = self._values.get("classic_load_balancers")
            assert result is not None, "Required property 'classic_load_balancers' is missing"
            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.ClassicLoadBalancerProperty"]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "ClassicLoadBalancersConfigProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.EbsBlockDeviceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "delete_on_termination": "deleteOnTermination",
            "encrypted": "encrypted",
            "iops": "iops",
            "snapshot_id": "snapshotId",
            "volume_size": "volumeSize",
            "volume_type": "volumeType",
        },
    )
    class EbsBlockDeviceProperty:
        def __init__(
            self,
            *,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            iops: typing.Optional[jsii.Number] = None,
            snapshot_id: typing.Optional[builtins.str] = None,
            volume_size: typing.Optional[jsii.Number] = None,
            volume_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a block device for an EBS volume.

            :param delete_on_termination: Indicates whether the EBS volume is deleted on instance termination. For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .
            :param encrypted: Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Amazon EBS Encryption <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-parameters>`_ in the *Amazon EC2 User Guide* . In no case can you remove encryption from an encrypted volume. Encrypted volumes can only be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ . This parameter is not returned by `DescribeImageAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html>`_ .
            :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000 - 16,000 IOPS - ``io1`` : 100 - 64,000 IOPS - ``io2`` : 100 - 256,000 IOPS For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS. This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS.
            :param snapshot_id: The ID of the snapshot.
            :param volume_size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size. The following are the supported sizes for each volume type: - ``gp2`` and ``gp3`` : 1 - 16,384 GiB - ``io1`` : 4 - 16,384 GiB - ``io2`` : 4 - 65,536 GiB - ``st1`` and ``sc1`` : 125 - 16,384 GiB - ``standard`` : 1 - 1024 GiB
            :param volume_type: The volume type. For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                ebs_block_device_property = ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                    delete_on_termination=False,
                    encrypted=False,
                    iops=123,
                    snapshot_id="snapshotId",
                    volume_size=123,
                    volume_type="volumeType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8886c06b4b6ffc2fd12b358b844b8cec0e460ac72bc835d6e99c49fc6e885e1c)
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
                check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
                check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
                check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
                check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if encrypted is not None:
                self._values["encrypted"] = encrypted
            if iops is not None:
                self._values["iops"] = iops
            if snapshot_id is not None:
                self._values["snapshot_id"] = snapshot_id
            if volume_size is not None:
                self._values["volume_size"] = volume_size
            if volume_type is not None:
                self._values["volume_type"] = volume_type

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the EBS volume is deleted on instance termination.

            For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def encrypted(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.

            The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Amazon EBS Encryption <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-parameters>`_ in the *Amazon EC2 User Guide* .

            In no case can you remove encryption from an encrypted volume.

            Encrypted volumes can only be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ .

            This parameter is not returned by `DescribeImageAttribute <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-encrypted
            '''
            result = self._values.get("encrypted")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def iops(self) -> typing.Optional[jsii.Number]:
            '''The number of I/O operations per second (IOPS).

            For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.

            The following are the supported values for each volume type:

            - ``gp3`` : 3,000 - 16,000 IOPS
            - ``io1`` : 100 - 64,000 IOPS
            - ``io2`` : 100 - 256,000 IOPS

            For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS.

            This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-iops
            '''
            result = self._values.get("iops")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def snapshot_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the snapshot.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-snapshotid
            '''
            result = self._values.get("snapshot_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def volume_size(self) -> typing.Optional[jsii.Number]:
            '''The size of the volume, in GiBs.

            You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size.

            The following are the supported sizes for each volume type:

            - ``gp2`` and ``gp3`` : 1 - 16,384 GiB
            - ``io1`` : 4 - 16,384 GiB
            - ``io2`` : 4 - 65,536 GiB
            - ``st1`` and ``sc1`` : 125 - 16,384 GiB
            - ``standard`` : 1 - 1024 GiB

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-volumesize
            '''
            result = self._values.get("volume_size")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def volume_type(self) -> typing.Optional[builtins.str]:
            '''The volume type.

            For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-ebsblockdevice.html#cfn-ec2-spotfleet-ebsblockdevice-volumetype
            '''
            result = self._values.get("volume_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "EbsBlockDeviceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "version": "version",
            "launch_template_id": "launchTemplateId",
            "launch_template_name": "launchTemplateName",
        },
    )
    class FleetLaunchTemplateSpecificationProperty:
        def __init__(
            self,
            *,
            version: builtins.str,
            launch_template_id: typing.Optional[builtins.str] = None,
            launch_template_name: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the launch template to be used by the Spot Fleet request for configuring Amazon EC2 instances.

            You must specify the following:

            - The ID or the name of the launch template, but not both.
            - The version of the launch template.

            ``FleetLaunchTemplateSpecification`` is a property of the `AWS::EC2::SpotFleet <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-spotfleet.html>`_ resource.

            For information about creating a launch template, see `AWS::EC2::LaunchTemplate <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html>`_ and `Create a launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ in the *Amazon EC2 User Guide* .

            For examples of launch templates, see `Examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples>`_ .

            :param version: The version number of the launch template. Specifying ``$Latest`` or ``$Default`` for the template version number is not supported. However, you can specify ``LatestVersionNumber`` or ``DefaultVersionNumber`` using the ``Fn::GetAtt`` intrinsic function. For more information, see `Fn::GetAtt <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate-return-values-fn--getatt>`_ .
            :param launch_template_id: The ID of the launch template. You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.
            :param launch_template_name: The name of the launch template. You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-fleetlaunchtemplatespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                fleet_launch_template_specification_property = ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty(
                    version="version",
                
                    # the properties below are optional
                    launch_template_id="launchTemplateId",
                    launch_template_name="launchTemplateName"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__af9cb9b64f5ef928643d5b676c935d9144d03fc2ffd12d202da6e2376578ded9)
                check_type(argname="argument version", value=version, expected_type=type_hints["version"])
                check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
                check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "version": version,
            }
            if launch_template_id is not None:
                self._values["launch_template_id"] = launch_template_id
            if launch_template_name is not None:
                self._values["launch_template_name"] = launch_template_name

        @builtins.property
        def version(self) -> builtins.str:
            '''The version number of the launch template.

            Specifying ``$Latest`` or ``$Default`` for the template version number is not supported. However, you can specify ``LatestVersionNumber`` or ``DefaultVersionNumber`` using the ``Fn::GetAtt`` intrinsic function. For more information, see `Fn::GetAtt <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate-return-values-fn--getatt>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-fleetlaunchtemplatespecification.html#cfn-ec2-spotfleet-fleetlaunchtemplatespecification-version
            '''
            result = self._values.get("version")
            assert result is not None, "Required property 'version' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def launch_template_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the launch template.

            You must specify the ``LaunchTemplateId`` or the ``LaunchTemplateName`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-fleetlaunchtemplatespecification.html#cfn-ec2-spotfleet-fleetlaunchtemplatespecification-launchtemplateid
            '''
            result = self._values.get("launch_template_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def launch_template_name(self) -> typing.Optional[builtins.str]:
            '''The name of the launch template.

            You must specify the ``LaunchTemplateName`` or the ``LaunchTemplateId`` , but not both.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-fleetlaunchtemplatespecification.html#cfn-ec2-spotfleet-fleetlaunchtemplatespecification-launchtemplatename
            '''
            result = self._values.get("launch_template_name")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "FleetLaunchTemplateSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.GroupIdentifierProperty",
        jsii_struct_bases=[],
        name_mapping={"group_id": "groupId"},
    )
    class GroupIdentifierProperty:
        def __init__(self, *, group_id: builtins.str) -> None:
            '''Describes a security group.

            :param group_id: The ID of the security group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-groupidentifier.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                group_identifier_property = ec2.CfnSpotFleet.GroupIdentifierProperty(
                    group_id="groupId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__23f8cbedcbc81ac996a29ec029803e6448e5fe8574e2c7eb1c67691089c43fc2)
                check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "group_id": group_id,
            }

        @builtins.property
        def group_id(self) -> builtins.str:
            '''The ID of the security group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-groupidentifier.html#cfn-ec2-spotfleet-groupidentifier-groupid
            '''
            result = self._values.get("group_id")
            assert result is not None, "Required property 'group_id' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "GroupIdentifierProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"arn": "arn"},
    )
    class IamInstanceProfileSpecificationProperty:
        def __init__(self, *, arn: typing.Optional[builtins.str] = None) -> None:
            '''Describes an IAM instance profile.

            :param arn: The Amazon Resource Name (ARN) of the instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-iaminstanceprofilespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                iam_instance_profile_specification_property = ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty(
                    arn="arn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ad379395b6ad9c3fadde77347a260722b64260ea5f6a5d7060f20bb3613219c3)
                check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if arn is not None:
                self._values["arn"] = arn

        @builtins.property
        def arn(self) -> typing.Optional[builtins.str]:
            '''The Amazon Resource Name (ARN) of the instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-iaminstanceprofilespecification.html#cfn-ec2-spotfleet-iaminstanceprofilespecification-arn
            '''
            result = self._values.get("arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "IamInstanceProfileSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.InstanceIpv6AddressProperty",
        jsii_struct_bases=[],
        name_mapping={"ipv6_address": "ipv6Address"},
    )
    class InstanceIpv6AddressProperty:
        def __init__(self, *, ipv6_address: builtins.str) -> None:
            '''Describes an IPv6 address.

            :param ipv6_address: The IPv6 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instanceipv6address.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_ipv6_address_property = ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                    ipv6_address="ipv6Address"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__be30e0d6c51e88da62517809d0c34c5193aaa5230acd3e38cf6b199a62510f5a)
                check_type(argname="argument ipv6_address", value=ipv6_address, expected_type=type_hints["ipv6_address"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "ipv6_address": ipv6_address,
            }

        @builtins.property
        def ipv6_address(self) -> builtins.str:
            '''The IPv6 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instanceipv6address.html#cfn-ec2-spotfleet-instanceipv6address-ipv6address
            '''
            result = self._values.get("ipv6_address")
            assert result is not None, "Required property 'ipv6_address' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceIpv6AddressProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "associate_public_ip_address": "associatePublicIpAddress",
            "delete_on_termination": "deleteOnTermination",
            "description": "description",
            "device_index": "deviceIndex",
            "groups": "groups",
            "ipv6_address_count": "ipv6AddressCount",
            "ipv6_addresses": "ipv6Addresses",
            "network_interface_id": "networkInterfaceId",
            "private_ip_addresses": "privateIpAddresses",
            "secondary_private_ip_address_count": "secondaryPrivateIpAddressCount",
            "subnet_id": "subnetId",
        },
    )
    class InstanceNetworkInterfaceSpecificationProperty:
        def __init__(
            self,
            *,
            associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            description: typing.Optional[builtins.str] = None,
            device_index: typing.Optional[jsii.Number] = None,
            groups: typing.Optional[typing.Sequence[builtins.str]] = None,
            ipv6_address_count: typing.Optional[jsii.Number] = None,
            ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.InstanceIpv6AddressProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            network_interface_id: typing.Optional[builtins.str] = None,
            private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.PrivateIpAddressSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
            subnet_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes a network interface.

            :param associate_public_ip_address: Indicates whether to assign a public IPv4 address to an instance you launch in a VPC. The public IP address can only be assigned to a network interface for eth0, and can only be assigned to a new network interface, not an existing one. You cannot specify more than one network interface in the request. If launching into a default subnet, the default value is ``true`` . AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `Amazon VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .
            :param delete_on_termination: Indicates whether the network interface is deleted when the instance is terminated.
            :param description: The description of the network interface. Applies only if creating a network interface when launching an instance.
            :param device_index: The position of the network interface in the attachment order. A primary network interface has a device index of 0. If you specify a network interface when launching an instance, you must specify the device index.
            :param groups: The IDs of the security groups for the network interface. Applies only if creating a network interface when launching an instance.
            :param ipv6_address_count: A number of IPv6 addresses to assign to the network interface. Amazon EC2 chooses the IPv6 addresses from the range of the subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch.
            :param ipv6_addresses: The IPv6 addresses to assign to the network interface. You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch.
            :param network_interface_id: The ID of the network interface. If you are creating a Spot Fleet, omit this parameter because you can’t specify a network interface ID in a launch specification.
            :param private_ip_addresses: The private IPv4 addresses to assign to the network interface. Only one private IPv4 address can be designated as primary. You cannot specify this option if you're launching more than one instance in a `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ request.
            :param secondary_private_ip_address_count: The number of secondary private IPv4 addresses. You can't specify this option and specify more than one private IP address using the private IP addresses option. You cannot specify this option if you're launching more than one instance in a `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ request.
            :param subnet_id: The ID of the subnet associated with the network interface. Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_network_interface_specification_property = ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty(
                    associate_public_ip_address=False,
                    delete_on_termination=False,
                    description="description",
                    device_index=123,
                    groups=["groups"],
                    ipv6_address_count=123,
                    ipv6_addresses=[ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                        ipv6_address="ipv6Address"
                    )],
                    network_interface_id="networkInterfaceId",
                    private_ip_addresses=[ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                        private_ip_address="privateIpAddress",
                
                        # the properties below are optional
                        primary=False
                    )],
                    secondary_private_ip_address_count=123,
                    subnet_id="subnetId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__159c47cbabf4008a2d6031dc275207d35cce8ec84e13fa89dac46cf0476fb179)
                check_type(argname="argument associate_public_ip_address", value=associate_public_ip_address, expected_type=type_hints["associate_public_ip_address"])
                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument device_index", value=device_index, expected_type=type_hints["device_index"])
                check_type(argname="argument groups", value=groups, expected_type=type_hints["groups"])
                check_type(argname="argument ipv6_address_count", value=ipv6_address_count, expected_type=type_hints["ipv6_address_count"])
                check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
                check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
                check_type(argname="argument private_ip_addresses", value=private_ip_addresses, expected_type=type_hints["private_ip_addresses"])
                check_type(argname="argument secondary_private_ip_address_count", value=secondary_private_ip_address_count, expected_type=type_hints["secondary_private_ip_address_count"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if associate_public_ip_address is not None:
                self._values["associate_public_ip_address"] = associate_public_ip_address
            if delete_on_termination is not None:
                self._values["delete_on_termination"] = delete_on_termination
            if description is not None:
                self._values["description"] = description
            if device_index is not None:
                self._values["device_index"] = device_index
            if groups is not None:
                self._values["groups"] = groups
            if ipv6_address_count is not None:
                self._values["ipv6_address_count"] = ipv6_address_count
            if ipv6_addresses is not None:
                self._values["ipv6_addresses"] = ipv6_addresses
            if network_interface_id is not None:
                self._values["network_interface_id"] = network_interface_id
            if private_ip_addresses is not None:
                self._values["private_ip_addresses"] = private_ip_addresses
            if secondary_private_ip_address_count is not None:
                self._values["secondary_private_ip_address_count"] = secondary_private_ip_address_count
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id

        @builtins.property
        def associate_public_ip_address(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to assign a public IPv4 address to an instance you launch in a VPC.

            The public IP address can only be assigned to a network interface for eth0, and can only be assigned to a new network interface, not an existing one. You cannot specify more than one network interface in the request. If launching into a default subnet, the default value is ``true`` .

            AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `Amazon VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-associatepublicipaddress
            '''
            result = self._values.get("associate_public_ip_address")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def delete_on_termination(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the network interface is deleted when the instance is terminated.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-deleteontermination
            '''
            result = self._values.get("delete_on_termination")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''The description of the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def device_index(self) -> typing.Optional[jsii.Number]:
            '''The position of the network interface in the attachment order.

            A primary network interface has a device index of 0.

            If you specify a network interface when launching an instance, you must specify the device index.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-deviceindex
            '''
            result = self._values.get("device_index")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def groups(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IDs of the security groups for the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-groups
            '''
            result = self._values.get("groups")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def ipv6_address_count(self) -> typing.Optional[jsii.Number]:
            '''A number of IPv6 addresses to assign to the network interface.

            Amazon EC2 chooses the IPv6 addresses from the range of the subnet. You cannot specify this option and the option to assign specific IPv6 addresses in the same request. You can specify this option if you've specified a minimum number of instances to launch.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-ipv6addresscount
            '''
            result = self._values.get("ipv6_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def ipv6_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceIpv6AddressProperty"]]]]:
            '''The IPv6 addresses to assign to the network interface.

            You cannot specify this option and the option to assign a number of IPv6 addresses in the same request. You cannot specify this option if you've specified a minimum number of instances to launch.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-ipv6addresses
            '''
            result = self._values.get("ipv6_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceIpv6AddressProperty"]]]], result)

        @builtins.property
        def network_interface_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the network interface.

            If you are creating a Spot Fleet, omit this parameter because you can’t specify a network interface ID in a launch specification.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-networkinterfaceid
            '''
            result = self._values.get("network_interface_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def private_ip_addresses(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.PrivateIpAddressSpecificationProperty"]]]]:
            '''The private IPv4 addresses to assign to the network interface.

            Only one private IPv4 address can be designated as primary. You cannot specify this option if you're launching more than one instance in a `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ request.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-privateipaddresses
            '''
            result = self._values.get("private_ip_addresses")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.PrivateIpAddressSpecificationProperty"]]]], result)

        @builtins.property
        def secondary_private_ip_address_count(self) -> typing.Optional[jsii.Number]:
            '''The number of secondary private IPv4 addresses.

            You can't specify this option and specify more than one private IP address using the private IP addresses option. You cannot specify this option if you're launching more than one instance in a `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ request.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-secondaryprivateipaddresscount
            '''
            result = self._values.get("secondary_private_ip_address_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the subnet associated with the network interface.

            Applies only if creating a network interface when launching an instance.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancenetworkinterfacespecification.html#cfn-ec2-spotfleet-instancenetworkinterfacespecification-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceNetworkInterfaceSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.InstanceRequirementsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={
            "accelerator_count": "acceleratorCount",
            "accelerator_manufacturers": "acceleratorManufacturers",
            "accelerator_names": "acceleratorNames",
            "accelerator_total_memory_mib": "acceleratorTotalMemoryMiB",
            "accelerator_types": "acceleratorTypes",
            "allowed_instance_types": "allowedInstanceTypes",
            "bare_metal": "bareMetal",
            "baseline_ebs_bandwidth_mbps": "baselineEbsBandwidthMbps",
            "burstable_performance": "burstablePerformance",
            "cpu_manufacturers": "cpuManufacturers",
            "excluded_instance_types": "excludedInstanceTypes",
            "instance_generations": "instanceGenerations",
            "local_storage": "localStorage",
            "local_storage_types": "localStorageTypes",
            "memory_gib_per_v_cpu": "memoryGiBPerVCpu",
            "memory_mib": "memoryMiB",
            "network_bandwidth_gbps": "networkBandwidthGbps",
            "network_interface_count": "networkInterfaceCount",
            "on_demand_max_price_percentage_over_lowest_price": "onDemandMaxPricePercentageOverLowestPrice",
            "require_hibernate_support": "requireHibernateSupport",
            "spot_max_price_percentage_over_lowest_price": "spotMaxPricePercentageOverLowestPrice",
            "total_local_storage_gb": "totalLocalStorageGb",
            "v_cpu_count": "vCpuCount",
        },
    )
    class InstanceRequirementsRequestProperty:
        def __init__(
            self,
            *,
            accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.AcceleratorCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
            accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            bare_metal: typing.Optional[builtins.str] = None,
            baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            burstable_performance: typing.Optional[builtins.str] = None,
            cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
            excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
            local_storage: typing.Optional[builtins.str] = None,
            local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
            memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.MemoryGiBPerVCpuRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.MemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.NetworkBandwidthGbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.NetworkInterfaceCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
            total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.TotalLocalStorageGBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.VCpuCountRangeRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with these attributes.

            You must specify ``VCpuCount`` and ``MemoryMiB`` . All other attributes are optional. Any unspecified optional attribute is set to its default.

            When you specify multiple attributes, you get instance types that satisfy all of the specified attributes. If you specify multiple values for an attribute, you get instance types that satisfy any of the specified values.

            To limit the list of instance types from which Amazon EC2 can identify matching instance types, you can use one of the following parameters, but not both in the same request:

            - ``AllowedInstanceTypes`` - The instance types to include in the list. All other instance types are ignored, even if they match your specified attributes.
            - ``ExcludedInstanceTypes`` - The instance types to exclude from the list, even if they match your specified attributes.

            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

               Attribute-based instance type selection is only supported when using Auto Scaling groups, EC2 Fleet, and Spot Fleet to launch instances. If you plan to use the launch template in the `launch instance wizard <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html>`_ , or with the `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ API or `AWS::EC2::Instance <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ AWS CloudFormation resource, you can't specify ``InstanceRequirements`` .

            For more information, see `Attribute-based instance type selection for EC2 Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html>`_ , `Attribute-based instance type selection for Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html>`_ , and `Spot placement score <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html>`_ in the *Amazon EC2 User Guide* .

            :param accelerator_count: The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance. To exclude accelerator-enabled instance types, set ``Max`` to ``0`` . Default: No minimum or maximum limits
            :param accelerator_manufacturers: Indicates whether instance types must have accelerators by specific manufacturers. - For instance types with AWS devices, specify ``amazon-web-services`` . - For instance types with AMD devices, specify ``amd`` . - For instance types with Habana devices, specify ``habana`` . - For instance types with NVIDIA devices, specify ``nvidia`` . - For instance types with Xilinx devices, specify ``xilinx`` . Default: Any manufacturer
            :param accelerator_names: The accelerators that must be on the instance type. - For instance types with NVIDIA A10G GPUs, specify ``a10g`` . - For instance types with NVIDIA A100 GPUs, specify ``a100`` . - For instance types with NVIDIA H100 GPUs, specify ``h100`` . - For instance types with AWS Inferentia chips, specify ``inferentia`` . - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` . - For instance types with NVIDIA K80 GPUs, specify ``k80`` . - For instance types with NVIDIA M60 GPUs, specify ``m60`` . - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` . - For instance types with NVIDIA T4 GPUs, specify ``t4`` . - For instance types with NVIDIA T4G GPUs, specify ``t4g`` . - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` . - For instance types with NVIDIA V100 GPUs, specify ``v100`` . Default: Any accelerator
            :param accelerator_total_memory_mib: The minimum and maximum amount of total accelerator memory, in MiB. Default: No minimum or maximum limits
            :param accelerator_types: The accelerator types that must be on the instance type. - To include instance types with GPU hardware, specify ``gpu`` . - To include instance types with FPGA hardware, specify ``fpga`` . - To include instance types with inference hardware, specify ``inference`` . Default: Any accelerator type
            :param allowed_instance_types: The instance types to apply your specified attributes against. All other instance types are ignored, even if they match your specified attributes. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` . Default: All instance types
            :param bare_metal: Indicates whether bare metal instance types must be included, excluded, or required. - To include bare metal instance types, specify ``included`` . - To require only bare metal instance types, specify ``required`` . - To exclude bare metal instance types, specify ``excluded`` . Default: ``excluded``
            :param baseline_ebs_bandwidth_mbps: The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps. For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* . Default: No minimum or maximum limits
            :param burstable_performance: Indicates whether burstable performance T instance types are included, excluded, or required. For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ . - To include burstable performance instance types, specify ``included`` . - To require only burstable performance instance types, specify ``required`` . - To exclude burstable performance instance types, specify ``excluded`` . Default: ``excluded``
            :param cpu_manufacturers: The CPU manufacturers to include. - For instance types with Intel CPUs, specify ``intel`` . - For instance types with AMD CPUs, specify ``amd`` . - For instance types with AWS CPUs, specify ``amazon-web-services`` . .. epigraph:: Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template. Default: Any manufacturer
            :param excluded_instance_types: The instance types to exclude. You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance family, type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` . For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types. .. epigraph:: If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` . Default: No excluded instance types
            :param instance_generations: Indicates whether current or previous generation instance types are included. The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* . For current generation instance types, specify ``current`` . For previous generation instance types, specify ``previous`` . Default: Current and previous generation instance types
            :param local_storage: Indicates whether instance types with instance store volumes are included, excluded, or required. For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* . - To include instance types with instance store volumes, specify ``included`` . - To require only instance types with instance store volumes, specify ``required`` . - To exclude instance types with instance store volumes, specify ``excluded`` . Default: ``included``
            :param local_storage_types: The type of local storage that is required. - For instance types with hard disk drive (HDD) storage, specify ``hdd`` . - For instance types with solid state drive (SSD) storage, specify ``ssd`` . Default: ``hdd`` and ``ssd``
            :param memory_gib_per_v_cpu: The minimum and maximum amount of memory per vCPU, in GiB. Default: No minimum or maximum limits
            :param memory_mib: The minimum and maximum amount of memory, in MiB.
            :param network_bandwidth_gbps: The minimum and maximum amount of baseline network bandwidth, in gigabits per second (Gbps). For more information, see `Amazon EC2 instance network bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html>`_ in the *Amazon EC2 User Guide* . Default: No minimum or maximum limits
            :param network_interface_count: The minimum and maximum number of network interfaces. Default: No minimum or maximum limits
            :param on_demand_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. Default: ``20``
            :param require_hibernate_support: Indicates whether instance types must support hibernation for On-Demand Instances. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ . Default: ``false``
            :param spot_max_price_percentage_over_lowest_price: [Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price. The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold. The parameter accepts an integer, which Amazon EC2 interprets as a percentage. To indicate no price protection threshold, specify a high value, such as ``999999`` . If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price. This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ . .. epigraph:: Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` . Default: ``100``
            :param total_local_storage_gb: The minimum and maximum amount of total local storage, in GB. Default: No minimum or maximum limits
            :param v_cpu_count: The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                instance_requirements_request_property = ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                    accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_manufacturers=["acceleratorManufacturers"],
                    accelerator_names=["acceleratorNames"],
                    accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                        max=123,
                        min=123
                    ),
                    accelerator_types=["acceleratorTypes"],
                    allowed_instance_types=["allowedInstanceTypes"],
                    bare_metal="bareMetal",
                    baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                        max=123,
                        min=123
                    ),
                    burstable_performance="burstablePerformance",
                    cpu_manufacturers=["cpuManufacturers"],
                    excluded_instance_types=["excludedInstanceTypes"],
                    instance_generations=["instanceGenerations"],
                    local_storage="localStorage",
                    local_storage_types=["localStorageTypes"],
                    memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                        max=123,
                        min=123
                    ),
                    memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                        max=123,
                        min=123
                    ),
                    network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                        max=123,
                        min=123
                    ),
                    network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                        max=123,
                        min=123
                    ),
                    on_demand_max_price_percentage_over_lowest_price=123,
                    require_hibernate_support=False,
                    spot_max_price_percentage_over_lowest_price=123,
                    total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                        max=123,
                        min=123
                    ),
                    v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                        max=123,
                        min=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d87a87ea48430983e2d408471599b12b60b4f49c59df11756641689dbbc395ce)
                check_type(argname="argument accelerator_count", value=accelerator_count, expected_type=type_hints["accelerator_count"])
                check_type(argname="argument accelerator_manufacturers", value=accelerator_manufacturers, expected_type=type_hints["accelerator_manufacturers"])
                check_type(argname="argument accelerator_names", value=accelerator_names, expected_type=type_hints["accelerator_names"])
                check_type(argname="argument accelerator_total_memory_mib", value=accelerator_total_memory_mib, expected_type=type_hints["accelerator_total_memory_mib"])
                check_type(argname="argument accelerator_types", value=accelerator_types, expected_type=type_hints["accelerator_types"])
                check_type(argname="argument allowed_instance_types", value=allowed_instance_types, expected_type=type_hints["allowed_instance_types"])
                check_type(argname="argument bare_metal", value=bare_metal, expected_type=type_hints["bare_metal"])
                check_type(argname="argument baseline_ebs_bandwidth_mbps", value=baseline_ebs_bandwidth_mbps, expected_type=type_hints["baseline_ebs_bandwidth_mbps"])
                check_type(argname="argument burstable_performance", value=burstable_performance, expected_type=type_hints["burstable_performance"])
                check_type(argname="argument cpu_manufacturers", value=cpu_manufacturers, expected_type=type_hints["cpu_manufacturers"])
                check_type(argname="argument excluded_instance_types", value=excluded_instance_types, expected_type=type_hints["excluded_instance_types"])
                check_type(argname="argument instance_generations", value=instance_generations, expected_type=type_hints["instance_generations"])
                check_type(argname="argument local_storage", value=local_storage, expected_type=type_hints["local_storage"])
                check_type(argname="argument local_storage_types", value=local_storage_types, expected_type=type_hints["local_storage_types"])
                check_type(argname="argument memory_gib_per_v_cpu", value=memory_gib_per_v_cpu, expected_type=type_hints["memory_gib_per_v_cpu"])
                check_type(argname="argument memory_mib", value=memory_mib, expected_type=type_hints["memory_mib"])
                check_type(argname="argument network_bandwidth_gbps", value=network_bandwidth_gbps, expected_type=type_hints["network_bandwidth_gbps"])
                check_type(argname="argument network_interface_count", value=network_interface_count, expected_type=type_hints["network_interface_count"])
                check_type(argname="argument on_demand_max_price_percentage_over_lowest_price", value=on_demand_max_price_percentage_over_lowest_price, expected_type=type_hints["on_demand_max_price_percentage_over_lowest_price"])
                check_type(argname="argument require_hibernate_support", value=require_hibernate_support, expected_type=type_hints["require_hibernate_support"])
                check_type(argname="argument spot_max_price_percentage_over_lowest_price", value=spot_max_price_percentage_over_lowest_price, expected_type=type_hints["spot_max_price_percentage_over_lowest_price"])
                check_type(argname="argument total_local_storage_gb", value=total_local_storage_gb, expected_type=type_hints["total_local_storage_gb"])
                check_type(argname="argument v_cpu_count", value=v_cpu_count, expected_type=type_hints["v_cpu_count"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if accelerator_count is not None:
                self._values["accelerator_count"] = accelerator_count
            if accelerator_manufacturers is not None:
                self._values["accelerator_manufacturers"] = accelerator_manufacturers
            if accelerator_names is not None:
                self._values["accelerator_names"] = accelerator_names
            if accelerator_total_memory_mib is not None:
                self._values["accelerator_total_memory_mib"] = accelerator_total_memory_mib
            if accelerator_types is not None:
                self._values["accelerator_types"] = accelerator_types
            if allowed_instance_types is not None:
                self._values["allowed_instance_types"] = allowed_instance_types
            if bare_metal is not None:
                self._values["bare_metal"] = bare_metal
            if baseline_ebs_bandwidth_mbps is not None:
                self._values["baseline_ebs_bandwidth_mbps"] = baseline_ebs_bandwidth_mbps
            if burstable_performance is not None:
                self._values["burstable_performance"] = burstable_performance
            if cpu_manufacturers is not None:
                self._values["cpu_manufacturers"] = cpu_manufacturers
            if excluded_instance_types is not None:
                self._values["excluded_instance_types"] = excluded_instance_types
            if instance_generations is not None:
                self._values["instance_generations"] = instance_generations
            if local_storage is not None:
                self._values["local_storage"] = local_storage
            if local_storage_types is not None:
                self._values["local_storage_types"] = local_storage_types
            if memory_gib_per_v_cpu is not None:
                self._values["memory_gib_per_v_cpu"] = memory_gib_per_v_cpu
            if memory_mib is not None:
                self._values["memory_mib"] = memory_mib
            if network_bandwidth_gbps is not None:
                self._values["network_bandwidth_gbps"] = network_bandwidth_gbps
            if network_interface_count is not None:
                self._values["network_interface_count"] = network_interface_count
            if on_demand_max_price_percentage_over_lowest_price is not None:
                self._values["on_demand_max_price_percentage_over_lowest_price"] = on_demand_max_price_percentage_over_lowest_price
            if require_hibernate_support is not None:
                self._values["require_hibernate_support"] = require_hibernate_support
            if spot_max_price_percentage_over_lowest_price is not None:
                self._values["spot_max_price_percentage_over_lowest_price"] = spot_max_price_percentage_over_lowest_price
            if total_local_storage_gb is not None:
                self._values["total_local_storage_gb"] = total_local_storage_gb
            if v_cpu_count is not None:
                self._values["v_cpu_count"] = v_cpu_count

        @builtins.property
        def accelerator_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.AcceleratorCountRequestProperty"]]:
            '''The minimum and maximum number of accelerators (GPUs, FPGAs, or AWS Inferentia chips) on an instance.

            To exclude accelerator-enabled instance types, set ``Max`` to ``0`` .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-acceleratorcount
            '''
            result = self._values.get("accelerator_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.AcceleratorCountRequestProperty"]], result)

        @builtins.property
        def accelerator_manufacturers(
            self,
        ) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether instance types must have accelerators by specific manufacturers.

            - For instance types with AWS devices, specify ``amazon-web-services`` .
            - For instance types with AMD devices, specify ``amd`` .
            - For instance types with Habana devices, specify ``habana`` .
            - For instance types with NVIDIA devices, specify ``nvidia`` .
            - For instance types with Xilinx devices, specify ``xilinx`` .

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-acceleratormanufacturers
            '''
            result = self._values.get("accelerator_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_names(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerators that must be on the instance type.

            - For instance types with NVIDIA A10G GPUs, specify ``a10g`` .
            - For instance types with NVIDIA A100 GPUs, specify ``a100`` .
            - For instance types with NVIDIA H100 GPUs, specify ``h100`` .
            - For instance types with AWS Inferentia chips, specify ``inferentia`` .
            - For instance types with NVIDIA GRID K520 GPUs, specify ``k520`` .
            - For instance types with NVIDIA K80 GPUs, specify ``k80`` .
            - For instance types with NVIDIA M60 GPUs, specify ``m60`` .
            - For instance types with AMD Radeon Pro V520 GPUs, specify ``radeon-pro-v520`` .
            - For instance types with NVIDIA T4 GPUs, specify ``t4`` .
            - For instance types with NVIDIA T4G GPUs, specify ``t4g`` .
            - For instance types with Xilinx VU9P FPGAs, specify ``vu9p`` .
            - For instance types with NVIDIA V100 GPUs, specify ``v100`` .

            Default: Any accelerator

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-acceleratornames
            '''
            result = self._values.get("accelerator_names")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def accelerator_total_memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty"]]:
            '''The minimum and maximum amount of total accelerator memory, in MiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-acceleratortotalmemorymib
            '''
            result = self._values.get("accelerator_total_memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty"]], result)

        @builtins.property
        def accelerator_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The accelerator types that must be on the instance type.

            - To include instance types with GPU hardware, specify ``gpu`` .
            - To include instance types with FPGA hardware, specify ``fpga`` .
            - To include instance types with inference hardware, specify ``inference`` .

            Default: Any accelerator type

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-acceleratortypes
            '''
            result = self._values.get("accelerator_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def allowed_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to apply your specified attributes against.

            All other instance types are ignored, even if they match your specified attributes.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to allow an instance type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will allow the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will allow all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``AllowedInstanceTypes`` , you can't specify ``ExcludedInstanceTypes`` .

            Default: All instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-allowedinstancetypes
            '''
            result = self._values.get("allowed_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def bare_metal(self) -> typing.Optional[builtins.str]:
            '''Indicates whether bare metal instance types must be included, excluded, or required.

            - To include bare metal instance types, specify ``included`` .
            - To require only bare metal instance types, specify ``required`` .
            - To exclude bare metal instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-baremetal
            '''
            result = self._values.get("bare_metal")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def baseline_ebs_bandwidth_mbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty"]]:
            '''The minimum and maximum baseline bandwidth to Amazon EBS, in Mbps.

            For more information, see `Amazon EBS–optimized instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-baselineebsbandwidthmbps
            '''
            result = self._values.get("baseline_ebs_bandwidth_mbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty"]], result)

        @builtins.property
        def burstable_performance(self) -> typing.Optional[builtins.str]:
            '''Indicates whether burstable performance T instance types are included, excluded, or required.

            For more information, see `Burstable performance instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html>`_ .

            - To include burstable performance instance types, specify ``included`` .
            - To require only burstable performance instance types, specify ``required`` .
            - To exclude burstable performance instance types, specify ``excluded`` .

            Default: ``excluded``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-burstableperformance
            '''
            result = self._values.get("burstable_performance")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def cpu_manufacturers(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The CPU manufacturers to include.

            - For instance types with Intel CPUs, specify ``intel`` .
            - For instance types with AMD CPUs, specify ``amd`` .
            - For instance types with AWS CPUs, specify ``amazon-web-services`` .

            .. epigraph::

               Don't confuse the CPU manufacturer with the CPU architecture. Instances will be launched with a compatible CPU architecture based on the Amazon Machine Image (AMI) that you specify in your launch template.

            Default: Any manufacturer

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-cpumanufacturers
            '''
            result = self._values.get("cpu_manufacturers")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def excluded_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The instance types to exclude.

            You can use strings with one or more wild cards, represented by an asterisk ( ``*`` ), to exclude an instance family, type, size, or generation. The following are examples: ``m5.8xlarge`` , ``c5*.*`` , ``m5a.*`` , ``r*`` , ``*3*`` .

            For example, if you specify ``c5*`` ,Amazon EC2 will exclude the entire C5 instance family, which includes all C5a and C5n instance types. If you specify ``m5a.*`` , Amazon EC2 will exclude all the M5a instance types, but not the M5n instance types.
            .. epigraph::

               If you specify ``ExcludedInstanceTypes`` , you can't specify ``AllowedInstanceTypes`` .

            Default: No excluded instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-excludedinstancetypes
            '''
            result = self._values.get("excluded_instance_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def instance_generations(self) -> typing.Optional[typing.List[builtins.str]]:
            '''Indicates whether current or previous generation instance types are included.

            The current generation instance types are recommended for use. Current generation instance types are typically the latest two to three generations in each instance family. For more information, see `Instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html>`_ in the *Amazon EC2 User Guide* .

            For current generation instance types, specify ``current`` .

            For previous generation instance types, specify ``previous`` .

            Default: Current and previous generation instance types

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-instancegenerations
            '''
            result = self._values.get("instance_generations")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def local_storage(self) -> typing.Optional[builtins.str]:
            '''Indicates whether instance types with instance store volumes are included, excluded, or required.

            For more information, `Amazon EC2 instance store <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html>`_ in the *Amazon EC2 User Guide* .

            - To include instance types with instance store volumes, specify ``included`` .
            - To require only instance types with instance store volumes, specify ``required`` .
            - To exclude instance types with instance store volumes, specify ``excluded`` .

            Default: ``included``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-localstorage
            '''
            result = self._values.get("local_storage")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def local_storage_types(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The type of local storage that is required.

            - For instance types with hard disk drive (HDD) storage, specify ``hdd`` .
            - For instance types with solid state drive (SSD) storage, specify ``ssd`` .

            Default: ``hdd`` and ``ssd``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-localstoragetypes
            '''
            result = self._values.get("local_storage_types")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        @builtins.property
        def memory_gib_per_v_cpu(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.MemoryGiBPerVCpuRequestProperty"]]:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-memorygibpervcpu
            '''
            result = self._values.get("memory_gib_per_v_cpu")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.MemoryGiBPerVCpuRequestProperty"]], result)

        @builtins.property
        def memory_mib(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.MemoryMiBRequestProperty"]]:
            '''The minimum and maximum amount of memory, in MiB.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-memorymib
            '''
            result = self._values.get("memory_mib")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.MemoryMiBRequestProperty"]], result)

        @builtins.property
        def network_bandwidth_gbps(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.NetworkBandwidthGbpsRequestProperty"]]:
            '''The minimum and maximum amount of baseline network bandwidth, in gigabits per second (Gbps).

            For more information, see `Amazon EC2 instance network bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-networkbandwidthgbps
            '''
            result = self._values.get("network_bandwidth_gbps")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.NetworkBandwidthGbpsRequestProperty"]], result)

        @builtins.property
        def network_interface_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.NetworkInterfaceCountRequestProperty"]]:
            '''The minimum and maximum number of network interfaces.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-networkinterfacecount
            '''
            result = self._values.get("network_interface_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.NetworkInterfaceCountRequestProperty"]], result)

        @builtins.property
        def on_demand_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price.

            The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            Default: ``20``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-ondemandmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("on_demand_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def require_hibernate_support(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether instance types must support hibernation for On-Demand Instances.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ .

            Default: ``false``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-requirehibernatesupport
            '''
            result = self._values.get("require_hibernate_support")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def spot_max_price_percentage_over_lowest_price(
            self,
        ) -> typing.Optional[jsii.Number]:
            '''[Price protection] The price protection threshold for Spot Instances, as a percentage higher than an identified Spot price.

            The identified Spot price is the Spot price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified Spot price is from the lowest priced current generation instance types, and failing that, from the lowest priced previous generation instance types that match your attributes. When Amazon EC2 selects instance types with your attributes, it will exclude instance types whose Spot price exceeds your specified threshold.

            The parameter accepts an integer, which Amazon EC2 interprets as a percentage.

            To indicate no price protection threshold, specify a high value, such as ``999999`` .

            If you set ``TargetCapacityUnitType`` to ``vcpu`` or ``memory-mib`` , the price protection threshold is applied based on the per-vCPU or per-memory price instead of the per-instance price.

            This parameter is not supported for `GetSpotPlacementScores <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetSpotPlacementScores.html>`_ and `GetInstanceTypesFromInstanceRequirements <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceTypesFromInstanceRequirements.html>`_ .
            .. epigraph::

               Only one of ``SpotMaxPricePercentageOverLowestPrice`` or ``MaxSpotPriceAsPercentageOfOptimalOnDemandPrice`` can be specified. If you don't specify either, then ``SpotMaxPricePercentageOverLowestPrice`` is used and the value for that parameter defaults to ``100`` .

            Default: ``100``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-spotmaxpricepercentageoverlowestprice
            '''
            result = self._values.get("spot_max_price_percentage_over_lowest_price")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def total_local_storage_gb(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TotalLocalStorageGBRequestProperty"]]:
            '''The minimum and maximum amount of total local storage, in GB.

            Default: No minimum or maximum limits

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-totallocalstoragegb
            '''
            result = self._values.get("total_local_storage_gb")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TotalLocalStorageGBRequestProperty"]], result)

        @builtins.property
        def v_cpu_count(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.VCpuCountRangeRequestProperty"]]:
            '''The minimum and maximum number of vCPUs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-instancerequirementsrequest.html#cfn-ec2-spotfleet-instancerequirementsrequest-vcpucount
            '''
            result = self._values.get("v_cpu_count")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.VCpuCountRangeRequestProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "InstanceRequirementsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.LaunchTemplateConfigProperty",
        jsii_struct_bases=[],
        name_mapping={
            "launch_template_specification": "launchTemplateSpecification",
            "overrides": "overrides",
        },
    )
    class LaunchTemplateConfigProperty:
        def __init__(
            self,
            *,
            launch_template_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.FleetLaunchTemplateSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.LaunchTemplateOverridesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
        ) -> None:
            '''Specifies a launch template and overrides.

            :param launch_template_specification: The launch template to use. Make sure that the launch template does not contain the ``NetworkInterfaceId`` parameter because you can't specify a network interface ID in a Spot Fleet.
            :param overrides: Any parameters that you specify override the same parameters in the launch template.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateconfig.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_config_property = ec2.CfnSpotFleet.LaunchTemplateConfigProperty(
                    launch_template_specification=ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty(
                        version="version",
                
                        # the properties below are optional
                        launch_template_id="launchTemplateId",
                        launch_template_name="launchTemplateName"
                    ),
                    overrides=[ec2.CfnSpotFleet.LaunchTemplateOverridesProperty(
                        availability_zone="availabilityZone",
                        instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        priority=123,
                        spot_price="spotPrice",
                        subnet_id="subnetId",
                        weighted_capacity=123
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d0ea174aaaccb24bf422f5f66f8ba4e6a263f8598d78d32532eeaa8bc3b949a1)
                check_type(argname="argument launch_template_specification", value=launch_template_specification, expected_type=type_hints["launch_template_specification"])
                check_type(argname="argument overrides", value=overrides, expected_type=type_hints["overrides"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if launch_template_specification is not None:
                self._values["launch_template_specification"] = launch_template_specification
            if overrides is not None:
                self._values["overrides"] = overrides

        @builtins.property
        def launch_template_specification(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.FleetLaunchTemplateSpecificationProperty"]]:
            '''The launch template to use.

            Make sure that the launch template does not contain the ``NetworkInterfaceId`` parameter because you can't specify a network interface ID in a Spot Fleet.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateconfig.html#cfn-ec2-spotfleet-launchtemplateconfig-launchtemplatespecification
            '''
            result = self._values.get("launch_template_specification")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.FleetLaunchTemplateSpecificationProperty"]], result)

        @builtins.property
        def overrides(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LaunchTemplateOverridesProperty"]]]]:
            '''Any parameters that you specify override the same parameters in the launch template.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateconfig.html#cfn-ec2-spotfleet-launchtemplateconfig-overrides
            '''
            result = self._values.get("overrides")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LaunchTemplateOverridesProperty"]]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateConfigProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.LaunchTemplateOverridesProperty",
        jsii_struct_bases=[],
        name_mapping={
            "availability_zone": "availabilityZone",
            "instance_requirements": "instanceRequirements",
            "instance_type": "instanceType",
            "priority": "priority",
            "spot_price": "spotPrice",
            "subnet_id": "subnetId",
            "weighted_capacity": "weightedCapacity",
        },
    )
    class LaunchTemplateOverridesProperty:
        def __init__(
            self,
            *,
            availability_zone: typing.Optional[builtins.str] = None,
            instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.InstanceRequirementsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_type: typing.Optional[builtins.str] = None,
            priority: typing.Optional[jsii.Number] = None,
            spot_price: typing.Optional[builtins.str] = None,
            subnet_id: typing.Optional[builtins.str] = None,
            weighted_capacity: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies overrides for a launch template.

            :param availability_zone: The Availability Zone in which to launch the instances.
            :param instance_requirements: The instance requirements. When you specify instance requirements, Amazon EC2 will identify instance types with the provided requirements, and then use your On-Demand and Spot allocation strategies to launch instances from these instance types, in the same way as when you specify a list of instance types. .. epigraph:: If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .
            :param instance_type: The instance type.
            :param priority: The priority for the launch template override. The highest priority is launched first. If ``OnDemandAllocationStrategy`` is set to ``prioritized`` , Spot Fleet uses priority to determine which launch template override to use first in fulfilling On-Demand capacity. If the Spot ``AllocationStrategy`` is set to ``capacityOptimizedPrioritized`` , Spot Fleet uses priority on a best-effort basis to determine which launch template override to use in fulfilling Spot capacity, but optimizes for capacity first. Valid values are whole numbers starting at ``0`` . The lower the number, the higher the priority. If no number is set, the launch template override has the lowest priority. You can set the same priority for different launch template overrides.
            :param spot_price: The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.
            :param subnet_id: The ID of the subnet in which to launch the instances.
            :param weighted_capacity: The number of units provided by the specified instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                launch_template_overrides_property = ec2.CfnSpotFleet.LaunchTemplateOverridesProperty(
                    availability_zone="availabilityZone",
                    instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                        accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    priority=123,
                    spot_price="spotPrice",
                    subnet_id="subnetId",
                    weighted_capacity=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__6881721673f4b31b8628e6827d756f492af26e7020e9cabef8ef937b58e786ea)
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
                check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
                check_type(argname="argument spot_price", value=spot_price, expected_type=type_hints["spot_price"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
                check_type(argname="argument weighted_capacity", value=weighted_capacity, expected_type=type_hints["weighted_capacity"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if instance_requirements is not None:
                self._values["instance_requirements"] = instance_requirements
            if instance_type is not None:
                self._values["instance_type"] = instance_type
            if priority is not None:
                self._values["priority"] = priority
            if spot_price is not None:
                self._values["spot_price"] = spot_price
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id
            if weighted_capacity is not None:
                self._values["weighted_capacity"] = weighted_capacity

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone in which to launch the instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_requirements(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceRequirementsRequestProperty"]]:
            '''The instance requirements.

            When you specify instance requirements, Amazon EC2 will identify instance types with the provided requirements, and then use your On-Demand and Spot allocation strategies to launch instances from these instance types, in the same way as when you specify a list of instance types.
            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-instancerequirements
            '''
            result = self._values.get("instance_requirements")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceRequirementsRequestProperty"]], result)

        @builtins.property
        def instance_type(self) -> typing.Optional[builtins.str]:
            '''The instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-instancetype
            '''
            result = self._values.get("instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def priority(self) -> typing.Optional[jsii.Number]:
            '''The priority for the launch template override. The highest priority is launched first.

            If ``OnDemandAllocationStrategy`` is set to ``prioritized`` , Spot Fleet uses priority to determine which launch template override to use first in fulfilling On-Demand capacity.

            If the Spot ``AllocationStrategy`` is set to ``capacityOptimizedPrioritized`` , Spot Fleet uses priority on a best-effort basis to determine which launch template override to use in fulfilling Spot capacity, but optimizes for capacity first.

            Valid values are whole numbers starting at ``0`` . The lower the number, the higher the priority. If no number is set, the launch template override has the lowest priority. You can set the same priority for different launch template overrides.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-priority
            '''
            result = self._values.get("priority")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def spot_price(self) -> typing.Optional[builtins.str]:
            '''The maximum price per unit hour that you are willing to pay for a Spot Instance.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-spotprice
            '''
            result = self._values.get("spot_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the subnet in which to launch the instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def weighted_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of units provided by the specified instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateoverrides.html#cfn-ec2-spotfleet-launchtemplateoverrides-weightedcapacity
            '''
            result = self._values.get("weighted_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LaunchTemplateOverridesProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.LoadBalancersConfigProperty",
        jsii_struct_bases=[],
        name_mapping={
            "classic_load_balancers_config": "classicLoadBalancersConfig",
            "target_groups_config": "targetGroupsConfig",
        },
    )
    class LoadBalancersConfigProperty:
        def __init__(
            self,
            *,
            classic_load_balancers_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.ClassicLoadBalancersConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            target_groups_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.TargetGroupsConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Specifies the Classic Load Balancers and target groups to attach to a Spot Fleet request.

            :param classic_load_balancers_config: The Classic Load Balancers.
            :param target_groups_config: The target groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-loadbalancersconfig.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                load_balancers_config_property = ec2.CfnSpotFleet.LoadBalancersConfigProperty(
                    classic_load_balancers_config=ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty(
                        classic_load_balancers=[ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                            name="name"
                        )]
                    ),
                    target_groups_config=ec2.CfnSpotFleet.TargetGroupsConfigProperty(
                        target_groups=[ec2.CfnSpotFleet.TargetGroupProperty(
                            arn="arn"
                        )]
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f21bd7eeb212de6045174d1b4425d8e8a7297d540af3851035fd520408fc3149)
                check_type(argname="argument classic_load_balancers_config", value=classic_load_balancers_config, expected_type=type_hints["classic_load_balancers_config"])
                check_type(argname="argument target_groups_config", value=target_groups_config, expected_type=type_hints["target_groups_config"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if classic_load_balancers_config is not None:
                self._values["classic_load_balancers_config"] = classic_load_balancers_config
            if target_groups_config is not None:
                self._values["target_groups_config"] = target_groups_config

        @builtins.property
        def classic_load_balancers_config(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.ClassicLoadBalancersConfigProperty"]]:
            '''The Classic Load Balancers.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-loadbalancersconfig.html#cfn-ec2-spotfleet-loadbalancersconfig-classicloadbalancersconfig
            '''
            result = self._values.get("classic_load_balancers_config")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.ClassicLoadBalancersConfigProperty"]], result)

        @builtins.property
        def target_groups_config(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TargetGroupsConfigProperty"]]:
            '''The target groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-loadbalancersconfig.html#cfn-ec2-spotfleet-loadbalancersconfig-targetgroupsconfig
            '''
            result = self._values.get("target_groups_config")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TargetGroupsConfigProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LoadBalancersConfigProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryGiBPerVCpuRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory per vCPU, in GiB.

            :param max: The maximum amount of memory per vCPU, in GiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory per vCPU, in GiB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorygibpervcpurequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_gi_bPer_vCpu_request_property = ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__e4475705f4e7446f3705401f8765729ad5a54f9335e190b73b27d5a93e4b2082)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory per vCPU, in GiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorygibpervcpurequest.html#cfn-ec2-spotfleet-memorygibpervcpurequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory per vCPU, in GiB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorygibpervcpurequest.html#cfn-ec2-spotfleet-memorygibpervcpurequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryGiBPerVCpuRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.MemoryMiBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class MemoryMiBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of memory, in MiB.

            :param max: The maximum amount of memory, in MiB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of memory, in MiB. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorymibrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                memory_mi_bRequest_property = ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__acc9c3c15cf6764adad644b17331efa0014c4cb1b01cbca0fc8810287bc3930a)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of memory, in MiB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorymibrequest.html#cfn-ec2-spotfleet-memorymibrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of memory, in MiB.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-memorymibrequest.html#cfn-ec2-spotfleet-memorymibrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "MemoryMiBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkBandwidthGbpsRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of baseline network bandwidth, in gigabits per second (Gbps).

            For more information, see `Amazon EC2 instance network bandwidth <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-network-bandwidth.html>`_ in the *Amazon EC2 User Guide* .

            Default: No minimum or maximum limits

            :param max: The maximum amount of network bandwidth, in Gbps. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of network bandwidth, in Gbps. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkbandwidthgbpsrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_bandwidth_gbps_request_property = ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__48acefcfcf4a24647056db3b94a5565ed7614642c316eb730eb0c315d2226571)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of network bandwidth, in Gbps.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkbandwidthgbpsrequest.html#cfn-ec2-spotfleet-networkbandwidthgbpsrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of network bandwidth, in Gbps.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkbandwidthgbpsrequest.html#cfn-ec2-spotfleet-networkbandwidthgbpsrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkBandwidthGbpsRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class NetworkInterfaceCountRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of network interfaces.

            :param max: The maximum number of network interfaces. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of network interfaces. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkinterfacecountrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_count_request_property = ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9f1c2a58b07974c9e23679ec83cb7b814966f49625f30a69b4cc73039ed7cc1b)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of network interfaces.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkinterfacecountrequest.html#cfn-ec2-spotfleet-networkinterfacecountrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of network interfaces.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-networkinterfacecountrequest.html#cfn-ec2-spotfleet-networkinterfacecountrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceCountRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"private_ip_address": "privateIpAddress", "primary": "primary"},
    )
    class PrivateIpAddressSpecificationProperty:
        def __init__(
            self,
            *,
            private_ip_address: builtins.str,
            primary: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Describes a secondary private IPv4 address for a network interface.

            :param private_ip_address: The private IPv4 address.
            :param primary: Indicates whether the private IPv4 address is the primary private IPv4 address. Only one IPv4 address can be designated as primary.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-privateipaddressspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_ip_address_specification_property = ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                    private_ip_address="privateIpAddress",
                
                    # the properties below are optional
                    primary=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b3fbf82fafbeb8256df96bc5af5ab7495e0fad3c525a6e21c0558c4942e59306)
                check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
                check_type(argname="argument primary", value=primary, expected_type=type_hints["primary"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "private_ip_address": private_ip_address,
            }
            if primary is not None:
                self._values["primary"] = primary

        @builtins.property
        def private_ip_address(self) -> builtins.str:
            '''The private IPv4 address.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-privateipaddressspecification.html#cfn-ec2-spotfleet-privateipaddressspecification-privateipaddress
            '''
            result = self._values.get("private_ip_address")
            assert result is not None, "Required property 'private_ip_address' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def primary(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the private IPv4 address is the primary private IPv4 address.

            Only one IPv4 address can be designated as primary.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-privateipaddressspecification.html#cfn-ec2-spotfleet-privateipaddressspecification-primary
            '''
            result = self._values.get("primary")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateIpAddressSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotCapacityRebalanceProperty",
        jsii_struct_bases=[],
        name_mapping={
            "replacement_strategy": "replacementStrategy",
            "termination_delay": "terminationDelay",
        },
    )
    class SpotCapacityRebalanceProperty:
        def __init__(
            self,
            *,
            replacement_strategy: typing.Optional[builtins.str] = None,
            termination_delay: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.

            For more information, see `Capacity rebalancing <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .

            :param replacement_strategy: The replacement strategy to use. Only available for fleets of type ``maintain`` . ``launch`` - Spot Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. Spot Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running. ``launch-before-terminate`` - Spot Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in ``TerminationDelay`` ), terminates the instances that received a rebalance notification.
            :param termination_delay: The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance. Required when ``ReplacementStrategy`` is set to ``launch-before-terminate`` . Not valid when ``ReplacementStrategy`` is set to ``launch`` . Valid values: Minimum value of ``120`` seconds. Maximum value of ``7200`` seconds.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotcapacityrebalance.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_capacity_rebalance_property = ec2.CfnSpotFleet.SpotCapacityRebalanceProperty(
                    replacement_strategy="replacementStrategy",
                    termination_delay=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__087c5e29b3a83067d823c986687f65a3448b4855906b3849664607c371191afe)
                check_type(argname="argument replacement_strategy", value=replacement_strategy, expected_type=type_hints["replacement_strategy"])
                check_type(argname="argument termination_delay", value=termination_delay, expected_type=type_hints["termination_delay"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if replacement_strategy is not None:
                self._values["replacement_strategy"] = replacement_strategy
            if termination_delay is not None:
                self._values["termination_delay"] = termination_delay

        @builtins.property
        def replacement_strategy(self) -> typing.Optional[builtins.str]:
            '''The replacement strategy to use. Only available for fleets of type ``maintain`` .

            ``launch`` - Spot Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet. Spot Fleet does not terminate the instances that receive a rebalance notification. You can terminate the old instances, or you can leave them running. You are charged for all instances while they are running.

            ``launch-before-terminate`` - Spot Fleet launches a new replacement Spot Instance when a rebalance notification is emitted for an existing Spot Instance in the fleet, and then, after a delay that you specify (in ``TerminationDelay`` ), terminates the instances that received a rebalance notification.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotcapacityrebalance.html#cfn-ec2-spotfleet-spotcapacityrebalance-replacementstrategy
            '''
            result = self._values.get("replacement_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def termination_delay(self) -> typing.Optional[jsii.Number]:
            '''The amount of time (in seconds) that Amazon EC2 waits before terminating the old Spot Instance after launching a new replacement Spot Instance.

            Required when ``ReplacementStrategy`` is set to ``launch-before-terminate`` .

            Not valid when ``ReplacementStrategy`` is set to ``launch`` .

            Valid values: Minimum value of ``120`` seconds. Maximum value of ``7200`` seconds.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotcapacityrebalance.html#cfn-ec2-spotfleet-spotcapacityrebalance-terminationdelay
            '''
            result = self._values.get("termination_delay")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotCapacityRebalanceProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotFleetLaunchSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "image_id": "imageId",
            "block_device_mappings": "blockDeviceMappings",
            "ebs_optimized": "ebsOptimized",
            "iam_instance_profile": "iamInstanceProfile",
            "instance_requirements": "instanceRequirements",
            "instance_type": "instanceType",
            "kernel_id": "kernelId",
            "key_name": "keyName",
            "monitoring": "monitoring",
            "network_interfaces": "networkInterfaces",
            "placement": "placement",
            "ramdisk_id": "ramdiskId",
            "security_groups": "securityGroups",
            "spot_price": "spotPrice",
            "subnet_id": "subnetId",
            "tag_specifications": "tagSpecifications",
            "user_data": "userData",
            "weighted_capacity": "weightedCapacity",
        },
    )
    class SpotFleetLaunchSpecificationProperty:
        def __init__(
            self,
            *,
            image_id: builtins.str,
            block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.BlockDeviceMappingProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            iam_instance_profile: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.IamInstanceProfileSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.InstanceRequirementsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            instance_type: typing.Optional[builtins.str] = None,
            kernel_id: typing.Optional[builtins.str] = None,
            key_name: typing.Optional[builtins.str] = None,
            monitoring: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotFleetMonitoringProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotPlacementProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            ramdisk_id: typing.Optional[builtins.str] = None,
            security_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.GroupIdentifierProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            spot_price: typing.Optional[builtins.str] = None,
            subnet_id: typing.Optional[builtins.str] = None,
            tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotFleetTagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            user_data: typing.Optional[builtins.str] = None,
            weighted_capacity: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''Specifies the launch specification for one or more Spot Instances.

            If you include On-Demand capacity in your fleet request, you can't use ``SpotFleetLaunchSpecification`` ; you must use `LaunchTemplateConfig <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-launchtemplateconfig.html>`_ .

            :param image_id: The ID of the AMI.
            :param block_device_mappings: One or more block devices that are mapped to the Spot Instances. You can't specify both a snapshot ID and an encryption value. This is because only blank volumes can be encrypted on creation. If a snapshot is the basis for a volume, it is not blank and its encryption status is used for the volume encryption status.
            :param ebs_optimized: Indicates whether the instances are optimized for EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS Optimized instance. Default: ``false`` Default: - false
            :param iam_instance_profile: The IAM instance profile.
            :param instance_requirements: The attributes for the instance types. When you specify instance attributes, Amazon EC2 will identify instance types with those attributes. .. epigraph:: If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .
            :param instance_type: The instance type.
            :param kernel_id: The ID of the kernel.
            :param key_name: The name of the key pair.
            :param monitoring: Enable or disable monitoring for the instances.
            :param network_interfaces: One or more network interfaces. If you specify a network interface, you must specify subnet IDs and security group IDs using the network interface. .. epigraph:: ``SpotFleetLaunchSpecification`` currently does not support Elastic Fabric Adapter (EFA). To specify an EFA, you must use `LaunchTemplateConfig <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_LaunchTemplateConfig.html>`_ .
            :param placement: The placement information.
            :param ramdisk_id: The ID of the RAM disk. Some kernels require additional drivers at launch. Check the kernel requirements for information about whether you need to specify a RAM disk. To find kernel requirements, refer to the AWS Resource Center and search for the kernel ID.
            :param security_groups: The security groups.
            :param spot_price: The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.
            :param subnet_id: The IDs of the subnets in which to launch the instances. To specify multiple subnets, separate them using commas; for example, "subnet-1234abcdeexample1, subnet-0987cdef6example2".
            :param tag_specifications: The tags to apply during creation.
            :param user_data: The base64-encoded user data that instances use when starting up. User data is limited to 16 KB.
            :param weighted_capacity: The number of units provided by the specified instance type. These are the same units that you chose to set the target capacity in terms of instances, or a performance characteristic such as vCPUs, memory, or I/O. If the target capacity divided by this value is not a whole number, Amazon EC2 rounds the number of instances to the next whole number. If this value is not specified, the default is 1.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_fleet_launch_specification_property = ec2.CfnSpotFleet.SpotFleetLaunchSpecificationProperty(
                    image_id="imageId",
                
                    # the properties below are optional
                    block_device_mappings=[ec2.CfnSpotFleet.BlockDeviceMappingProperty(
                        device_name="deviceName",
                
                        # the properties below are optional
                        ebs=ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                            delete_on_termination=False,
                            encrypted=False,
                            iops=123,
                            snapshot_id="snapshotId",
                            volume_size=123,
                            volume_type="volumeType"
                        ),
                        no_device="noDevice",
                        virtual_name="virtualName"
                    )],
                    ebs_optimized=False,
                    iam_instance_profile=ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty(
                        arn="arn"
                    ),
                    instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                        accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_manufacturers=["acceleratorManufacturers"],
                        accelerator_names=["acceleratorNames"],
                        accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        accelerator_types=["acceleratorTypes"],
                        allowed_instance_types=["allowedInstanceTypes"],
                        bare_metal="bareMetal",
                        baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        burstable_performance="burstablePerformance",
                        cpu_manufacturers=["cpuManufacturers"],
                        excluded_instance_types=["excludedInstanceTypes"],
                        instance_generations=["instanceGenerations"],
                        local_storage="localStorage",
                        local_storage_types=["localStorageTypes"],
                        memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                            max=123,
                            min=123
                        ),
                        memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                            max=123,
                            min=123
                        ),
                        network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                            max=123,
                            min=123
                        ),
                        on_demand_max_price_percentage_over_lowest_price=123,
                        require_hibernate_support=False,
                        spot_max_price_percentage_over_lowest_price=123,
                        total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                            max=123,
                            min=123
                        ),
                        v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                            max=123,
                            min=123
                        )
                    ),
                    instance_type="instanceType",
                    kernel_id="kernelId",
                    key_name="keyName",
                    monitoring=ec2.CfnSpotFleet.SpotFleetMonitoringProperty(
                        enabled=False
                    ),
                    network_interfaces=[ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty(
                        associate_public_ip_address=False,
                        delete_on_termination=False,
                        description="description",
                        device_index=123,
                        groups=["groups"],
                        ipv6_address_count=123,
                        ipv6_addresses=[ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                            ipv6_address="ipv6Address"
                        )],
                        network_interface_id="networkInterfaceId",
                        private_ip_addresses=[ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                            private_ip_address="privateIpAddress",
                
                            # the properties below are optional
                            primary=False
                        )],
                        secondary_private_ip_address_count=123,
                        subnet_id="subnetId"
                    )],
                    placement=ec2.CfnSpotFleet.SpotPlacementProperty(
                        availability_zone="availabilityZone",
                        group_name="groupName",
                        tenancy="tenancy"
                    ),
                    ramdisk_id="ramdiskId",
                    security_groups=[ec2.CfnSpotFleet.GroupIdentifierProperty(
                        group_id="groupId"
                    )],
                    spot_price="spotPrice",
                    subnet_id="subnetId",
                    tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                        resource_type="resourceType",
                        tags=[CfnTag(
                            key="key",
                            value="value"
                        )]
                    )],
                    user_data="userData",
                    weighted_capacity=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c2894b30d6a2236ca5cb1a1d15ba8bc5ef33a3ac03eef681d6f01a792d338765)
                check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
                check_type(argname="argument block_device_mappings", value=block_device_mappings, expected_type=type_hints["block_device_mappings"])
                check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
                check_type(argname="argument iam_instance_profile", value=iam_instance_profile, expected_type=type_hints["iam_instance_profile"])
                check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
                check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                check_type(argname="argument kernel_id", value=kernel_id, expected_type=type_hints["kernel_id"])
                check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
                check_type(argname="argument monitoring", value=monitoring, expected_type=type_hints["monitoring"])
                check_type(argname="argument network_interfaces", value=network_interfaces, expected_type=type_hints["network_interfaces"])
                check_type(argname="argument placement", value=placement, expected_type=type_hints["placement"])
                check_type(argname="argument ramdisk_id", value=ramdisk_id, expected_type=type_hints["ramdisk_id"])
                check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
                check_type(argname="argument spot_price", value=spot_price, expected_type=type_hints["spot_price"])
                check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
                check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
                check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
                check_type(argname="argument weighted_capacity", value=weighted_capacity, expected_type=type_hints["weighted_capacity"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "image_id": image_id,
            }
            if block_device_mappings is not None:
                self._values["block_device_mappings"] = block_device_mappings
            if ebs_optimized is not None:
                self._values["ebs_optimized"] = ebs_optimized
            if iam_instance_profile is not None:
                self._values["iam_instance_profile"] = iam_instance_profile
            if instance_requirements is not None:
                self._values["instance_requirements"] = instance_requirements
            if instance_type is not None:
                self._values["instance_type"] = instance_type
            if kernel_id is not None:
                self._values["kernel_id"] = kernel_id
            if key_name is not None:
                self._values["key_name"] = key_name
            if monitoring is not None:
                self._values["monitoring"] = monitoring
            if network_interfaces is not None:
                self._values["network_interfaces"] = network_interfaces
            if placement is not None:
                self._values["placement"] = placement
            if ramdisk_id is not None:
                self._values["ramdisk_id"] = ramdisk_id
            if security_groups is not None:
                self._values["security_groups"] = security_groups
            if spot_price is not None:
                self._values["spot_price"] = spot_price
            if subnet_id is not None:
                self._values["subnet_id"] = subnet_id
            if tag_specifications is not None:
                self._values["tag_specifications"] = tag_specifications
            if user_data is not None:
                self._values["user_data"] = user_data
            if weighted_capacity is not None:
                self._values["weighted_capacity"] = weighted_capacity

        @builtins.property
        def image_id(self) -> builtins.str:
            '''The ID of the AMI.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-imageid
            '''
            result = self._values.get("image_id")
            assert result is not None, "Required property 'image_id' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def block_device_mappings(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.BlockDeviceMappingProperty"]]]]:
            '''One or more block devices that are mapped to the Spot Instances.

            You can't specify both a snapshot ID and an encryption value. This is because only blank volumes can be encrypted on creation. If a snapshot is the basis for a volume, it is not blank and its encryption status is used for the volume encryption status.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-blockdevicemappings
            '''
            result = self._values.get("block_device_mappings")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.BlockDeviceMappingProperty"]]]], result)

        @builtins.property
        def ebs_optimized(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether the instances are optimized for EBS I/O.

            This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS Optimized instance.

            Default: ``false``

            :default: - false

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-ebsoptimized
            '''
            result = self._values.get("ebs_optimized")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def iam_instance_profile(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.IamInstanceProfileSpecificationProperty"]]:
            '''The IAM instance profile.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-iaminstanceprofile
            '''
            result = self._values.get("iam_instance_profile")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.IamInstanceProfileSpecificationProperty"]], result)

        @builtins.property
        def instance_requirements(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceRequirementsRequestProperty"]]:
            '''The attributes for the instance types.

            When you specify instance attributes, Amazon EC2 will identify instance types with those attributes.
            .. epigraph::

               If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-instancerequirements
            '''
            result = self._values.get("instance_requirements")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceRequirementsRequestProperty"]], result)

        @builtins.property
        def instance_type(self) -> typing.Optional[builtins.str]:
            '''The instance type.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-instancetype
            '''
            result = self._values.get("instance_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def kernel_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the kernel.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-kernelid
            '''
            result = self._values.get("kernel_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def key_name(self) -> typing.Optional[builtins.str]:
            '''The name of the key pair.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-keyname
            '''
            result = self._values.get("key_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def monitoring(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetMonitoringProperty"]]:
            '''Enable or disable monitoring for the instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-monitoring
            '''
            result = self._values.get("monitoring")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetMonitoringProperty"]], result)

        @builtins.property
        def network_interfaces(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty"]]]]:
            '''One or more network interfaces.

            If you specify a network interface, you must specify subnet IDs and security group IDs using the network interface.
            .. epigraph::

               ``SpotFleetLaunchSpecification`` currently does not support Elastic Fabric Adapter (EFA). To specify an EFA, you must use `LaunchTemplateConfig <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_LaunchTemplateConfig.html>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-networkinterfaces
            '''
            result = self._values.get("network_interfaces")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty"]]]], result)

        @builtins.property
        def placement(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotPlacementProperty"]]:
            '''The placement information.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-placement
            '''
            result = self._values.get("placement")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotPlacementProperty"]], result)

        @builtins.property
        def ramdisk_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the RAM disk.

            Some kernels require additional drivers at launch. Check the kernel requirements for information about whether you need to specify a RAM disk. To find kernel requirements, refer to the AWS Resource Center and search for the kernel ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-ramdiskid
            '''
            result = self._values.get("ramdisk_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def security_groups(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.GroupIdentifierProperty"]]]]:
            '''The security groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-securitygroups
            '''
            result = self._values.get("security_groups")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.GroupIdentifierProperty"]]]], result)

        @builtins.property
        def spot_price(self) -> typing.Optional[builtins.str]:
            '''The maximum price per unit hour that you are willing to pay for a Spot Instance.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-spotprice
            '''
            result = self._values.get("spot_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def subnet_id(self) -> typing.Optional[builtins.str]:
            '''The IDs of the subnets in which to launch the instances.

            To specify multiple subnets, separate them using commas; for example, "subnet-1234abcdeexample1, subnet-0987cdef6example2".

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-subnetid
            '''
            result = self._values.get("subnet_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tag_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetTagSpecificationProperty"]]]]:
            '''The tags to apply during creation.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-tagspecifications
            '''
            result = self._values.get("tag_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetTagSpecificationProperty"]]]], result)

        @builtins.property
        def user_data(self) -> typing.Optional[builtins.str]:
            '''The base64-encoded user data that instances use when starting up.

            User data is limited to 16 KB.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-userdata
            '''
            result = self._values.get("user_data")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def weighted_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of units provided by the specified instance type.

            These are the same units that you chose to set the target capacity in terms of instances, or a performance characteristic such as vCPUs, memory, or I/O.

            If the target capacity divided by this value is not a whole number, Amazon EC2 rounds the number of instances to the next whole number. If this value is not specified, the default is 1.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetlaunchspecification.html#cfn-ec2-spotfleet-spotfleetlaunchspecification-weightedcapacity
            '''
            result = self._values.get("weighted_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotFleetLaunchSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotFleetMonitoringProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled"},
    )
    class SpotFleetMonitoringProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Describes whether monitoring is enabled.

            :param enabled: Enables monitoring for the instance. Default: ``false`` Default: - false

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetmonitoring.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_fleet_monitoring_property = ec2.CfnSpotFleet.SpotFleetMonitoringProperty(
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__d656e3fbe7f2125890e405b7fc3a48da1eda305699c018bc23e23df2b093e134)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Enables monitoring for the instance.

            Default: ``false``

            :default: - false

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetmonitoring.html#cfn-ec2-spotfleet-spotfleetmonitoring-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotFleetMonitoringProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotFleetRequestConfigDataProperty",
        jsii_struct_bases=[],
        name_mapping={
            "iam_fleet_role": "iamFleetRole",
            "target_capacity": "targetCapacity",
            "allocation_strategy": "allocationStrategy",
            "context": "context",
            "excess_capacity_termination_policy": "excessCapacityTerminationPolicy",
            "instance_interruption_behavior": "instanceInterruptionBehavior",
            "instance_pools_to_use_count": "instancePoolsToUseCount",
            "launch_specifications": "launchSpecifications",
            "launch_template_configs": "launchTemplateConfigs",
            "load_balancers_config": "loadBalancersConfig",
            "on_demand_allocation_strategy": "onDemandAllocationStrategy",
            "on_demand_max_total_price": "onDemandMaxTotalPrice",
            "on_demand_target_capacity": "onDemandTargetCapacity",
            "replace_unhealthy_instances": "replaceUnhealthyInstances",
            "spot_maintenance_strategies": "spotMaintenanceStrategies",
            "spot_max_total_price": "spotMaxTotalPrice",
            "spot_price": "spotPrice",
            "tag_specifications": "tagSpecifications",
            "target_capacity_unit_type": "targetCapacityUnitType",
            "terminate_instances_with_expiration": "terminateInstancesWithExpiration",
            "type": "type",
            "valid_from": "validFrom",
            "valid_until": "validUntil",
        },
    )
    class SpotFleetRequestConfigDataProperty:
        def __init__(
            self,
            *,
            iam_fleet_role: builtins.str,
            target_capacity: jsii.Number,
            allocation_strategy: typing.Optional[builtins.str] = None,
            context: typing.Optional[builtins.str] = None,
            excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
            instance_interruption_behavior: typing.Optional[builtins.str] = None,
            instance_pools_to_use_count: typing.Optional[jsii.Number] = None,
            launch_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotFleetLaunchSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            launch_template_configs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.LaunchTemplateConfigProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            load_balancers_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.LoadBalancersConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            on_demand_allocation_strategy: typing.Optional[builtins.str] = None,
            on_demand_max_total_price: typing.Optional[builtins.str] = None,
            on_demand_target_capacity: typing.Optional[jsii.Number] = None,
            replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            spot_maintenance_strategies: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotMaintenanceStrategiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            spot_max_total_price: typing.Optional[builtins.str] = None,
            spot_price: typing.Optional[builtins.str] = None,
            tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotFleetTagSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
            target_capacity_unit_type: typing.Optional[builtins.str] = None,
            terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            type: typing.Optional[builtins.str] = None,
            valid_from: typing.Optional[builtins.str] = None,
            valid_until: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Specifies the configuration of a Spot Fleet request.

            For more information, see `Spot Fleet <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet.html>`_ in the *Amazon EC2 User Guide* .

            You must specify either ``LaunchSpecifications`` or ``LaunchTemplateConfigs`` .

            :param iam_fleet_role: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants the Spot Fleet the permission to request, launch, terminate, and tag instances on your behalf. For more information, see `Spot Fleet Prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html#spot-fleet-prerequisites>`_ in the *Amazon EC2 User Guide for Linux Instances* . Spot Fleet can terminate Spot Instances on your behalf when you cancel its Spot Fleet request or when the Spot Fleet request expires, if you set ``TerminateInstancesWithExpiration`` .
            :param target_capacity: The number of units to request for the Spot Fleet. You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is ``maintain`` , you can specify a target capacity of 0 and add capacity later.
            :param allocation_strategy: The strategy that determines how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the Spot Fleet launch configuration. For more information, see `Allocation strategies for Spot Instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-allocation-strategy.html>`_ in the *Amazon EC2 User Guide* . - **priceCapacityOptimized (recommended)** - Spot Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. Spot Fleet then requests Spot Instances from the lowest priced of these pools. - **capacityOptimized** - Spot Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. To give certain instance types a higher chance of launching first, use ``capacityOptimizedPrioritized`` . Set a priority for each instance type by using the ``Priority`` parameter for ``LaunchTemplateOverrides`` . You can assign the same priority to different ``LaunchTemplateOverrides`` . EC2 implements the priorities on a best-effort basis, but optimizes for capacity first. ``capacityOptimizedPrioritized`` is supported only if your Spot Fleet uses a launch template. Note that if the ``OnDemandAllocationStrategy`` is set to ``prioritized`` , the same priority is applied when fulfilling On-Demand capacity. - **diversified** - Spot Fleet requests instances from all of the Spot Instance pools that you specify. - **lowestPrice** - Spot Fleet requests instances from the lowest priced Spot Instance pool that has available capacity. If the lowest priced pool doesn't have available capacity, the Spot Instances come from the next lowest priced pool that has available capacity. If a pool runs out of capacity before fulfilling your desired capacity, Spot Fleet will continue to fulfill your request by drawing from the next lowest priced pool. To ensure that your desired capacity is met, you might receive Spot Instances from several pools. Because this strategy only considers instance price and not capacity availability, it might lead to high interruption rates. Default: ``lowestPrice``
            :param context: Reserved.
            :param excess_capacity_termination_policy: Indicates whether running Spot Instances should be terminated if you decrease the target capacity of the Spot Fleet request below the current size of the Spot Fleet. Supported only for fleets of type ``maintain`` .
            :param instance_interruption_behavior: The behavior when a Spot Instance is interrupted. The default is ``terminate`` .
            :param instance_pools_to_use_count: The number of Spot pools across which to allocate your target Spot capacity. Valid only when Spot *AllocationStrategy* is set to ``lowest-price`` . Spot Fleet selects the cheapest Spot pools and evenly allocates your target Spot capacity across the number of Spot pools that you specify. Note that Spot Fleet attempts to draw Spot Instances from the number of pools that you specify on a best effort basis. If a pool runs out of Spot capacity before fulfilling your target capacity, Spot Fleet will continue to fulfill your request by drawing from the next cheapest pool. To ensure that your target capacity is met, you might receive Spot Instances from more than the number of pools that you specified. Similarly, if most of the pools have no Spot capacity, you might receive your full target capacity from fewer than the number of pools that you specified.
            :param launch_specifications: The launch specifications for the Spot Fleet request. If you specify ``LaunchSpecifications`` , you can't specify ``LaunchTemplateConfigs`` .
            :param launch_template_configs: The launch template and overrides. If you specify ``LaunchTemplateConfigs`` , you can't specify ``LaunchSpecifications`` .
            :param load_balancers_config: One or more Classic Load Balancers and target groups to attach to the Spot Fleet request. Spot Fleet registers the running Spot Instances with the specified Classic Load Balancers and target groups. With Network Load Balancers, Spot Fleet cannot register instances that have the following instance types: C1, CC1, CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, HS1, M1, M2, M3, and T1.
            :param on_demand_allocation_strategy: The order of the launch template overrides to use in fulfilling On-Demand capacity. If you specify ``lowestPrice`` , Spot Fleet uses price to determine the order, launching the lowest price first. If you specify ``prioritized`` , Spot Fleet uses the priority that you assign to each Spot Fleet launch template override, launching the highest priority first. If you do not specify a value, Spot Fleet defaults to ``lowestPrice`` .
            :param on_demand_max_total_price: The maximum amount per hour for On-Demand Instances that you're willing to pay. You can use the ``onDemandMaxTotalPrice`` parameter, the ``spotMaxTotalPrice`` parameter, or both parameters to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, Spot Fleet will launch instances until it reaches the maximum amount you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity. .. epigraph:: If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``onDemandMaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``onDemandMaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .
            :param on_demand_target_capacity: The number of On-Demand units to request. You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is ``maintain`` , you can specify a target capacity of 0 and add capacity later.
            :param replace_unhealthy_instances: Indicates whether Spot Fleet should replace unhealthy instances.
            :param spot_maintenance_strategies: The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.
            :param spot_max_total_price: The maximum amount per hour for Spot Instances that you're willing to pay. You can use the ``spotMaxTotalPrice`` parameter, the ``onDemandMaxTotalPrice`` parameter, or both parameters to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, Spot Fleet will launch instances until it reaches the maximum amount you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity. .. epigraph:: If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``spotMaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``spotMaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .
            :param spot_price: The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.
            :param tag_specifications: The key-value pair for tagging the Spot Fleet request on creation. The value for ``ResourceType`` must be ``spot-fleet-request`` , otherwise the Spot Fleet request fails. To tag instances at launch, specify the tags in the `launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ (valid only if you use ``LaunchTemplateConfigs`` ) or in the ``[SpotFleetTagSpecification](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetTagSpecification.html)`` (valid only if you use ``LaunchSpecifications`` ). For information about tagging after launch, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ .
            :param target_capacity_unit_type: The unit for the target capacity. You can specify this parameter only when using attribute-based instance type selection. Default: ``units`` (the number of instances)
            :param terminate_instances_with_expiration: Indicates whether running Spot Instances are terminated when the Spot Fleet request expires.
            :param type: The type of request. Indicates whether the Spot Fleet only requests the target capacity or also attempts to maintain it. When this value is ``request`` , the Spot Fleet only places the required requests. It does not attempt to replenish Spot Instances if capacity is diminished, nor does it submit requests in alternative Spot pools if capacity is not available. When this value is ``maintain`` , the Spot Fleet maintains the target capacity. The Spot Fleet places the required requests to meet capacity and automatically replenishes any interrupted instances. Default: ``maintain`` . ``instant`` is listed but is not used by Spot Fleet.
            :param valid_from: The start date and time of the request, in UTC format ( *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). By default, Amazon EC2 starts fulfilling the request immediately.
            :param valid_until: The end date and time of the request, in UTC format ( *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z). After the end date and time, no new Spot Instance requests are placed or able to fulfill the request. If no value is specified, the Spot Fleet request remains until you cancel it.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_fleet_request_config_data_property = ec2.CfnSpotFleet.SpotFleetRequestConfigDataProperty(
                    iam_fleet_role="iamFleetRole",
                    target_capacity=123,
                
                    # the properties below are optional
                    allocation_strategy="allocationStrategy",
                    context="context",
                    excess_capacity_termination_policy="excessCapacityTerminationPolicy",
                    instance_interruption_behavior="instanceInterruptionBehavior",
                    instance_pools_to_use_count=123,
                    launch_specifications=[ec2.CfnSpotFleet.SpotFleetLaunchSpecificationProperty(
                        image_id="imageId",
                
                        # the properties below are optional
                        block_device_mappings=[ec2.CfnSpotFleet.BlockDeviceMappingProperty(
                            device_name="deviceName",
                
                            # the properties below are optional
                            ebs=ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                                delete_on_termination=False,
                                encrypted=False,
                                iops=123,
                                snapshot_id="snapshotId",
                                volume_size=123,
                                volume_type="volumeType"
                            ),
                            no_device="noDevice",
                            virtual_name="virtualName"
                        )],
                        ebs_optimized=False,
                        iam_instance_profile=ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty(
                            arn="arn"
                        ),
                        instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        kernel_id="kernelId",
                        key_name="keyName",
                        monitoring=ec2.CfnSpotFleet.SpotFleetMonitoringProperty(
                            enabled=False
                        ),
                        network_interfaces=[ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty(
                            associate_public_ip_address=False,
                            delete_on_termination=False,
                            description="description",
                            device_index=123,
                            groups=["groups"],
                            ipv6_address_count=123,
                            ipv6_addresses=[ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                                ipv6_address="ipv6Address"
                            )],
                            network_interface_id="networkInterfaceId",
                            private_ip_addresses=[ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                                private_ip_address="privateIpAddress",
                
                                # the properties below are optional
                                primary=False
                            )],
                            secondary_private_ip_address_count=123,
                            subnet_id="subnetId"
                        )],
                        placement=ec2.CfnSpotFleet.SpotPlacementProperty(
                            availability_zone="availabilityZone",
                            group_name="groupName",
                            tenancy="tenancy"
                        ),
                        ramdisk_id="ramdiskId",
                        security_groups=[ec2.CfnSpotFleet.GroupIdentifierProperty(
                            group_id="groupId"
                        )],
                        spot_price="spotPrice",
                        subnet_id="subnetId",
                        tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                            resource_type="resourceType",
                            tags=[CfnTag(
                                key="key",
                                value="value"
                            )]
                        )],
                        user_data="userData",
                        weighted_capacity=123
                    )],
                    launch_template_configs=[ec2.CfnSpotFleet.LaunchTemplateConfigProperty(
                        launch_template_specification=ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty(
                            version="version",
                
                            # the properties below are optional
                            launch_template_id="launchTemplateId",
                            launch_template_name="launchTemplateName"
                        ),
                        overrides=[ec2.CfnSpotFleet.LaunchTemplateOverridesProperty(
                            availability_zone="availabilityZone",
                            instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                                accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                accelerator_manufacturers=["acceleratorManufacturers"],
                                accelerator_names=["acceleratorNames"],
                                accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                accelerator_types=["acceleratorTypes"],
                                allowed_instance_types=["allowedInstanceTypes"],
                                bare_metal="bareMetal",
                                baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                burstable_performance="burstablePerformance",
                                cpu_manufacturers=["cpuManufacturers"],
                                excluded_instance_types=["excludedInstanceTypes"],
                                instance_generations=["instanceGenerations"],
                                local_storage="localStorage",
                                local_storage_types=["localStorageTypes"],
                                memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                on_demand_max_price_percentage_over_lowest_price=123,
                                require_hibernate_support=False,
                                spot_max_price_percentage_over_lowest_price=123,
                                total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                    max=123,
                                    min=123
                                )
                            ),
                            instance_type="instanceType",
                            priority=123,
                            spot_price="spotPrice",
                            subnet_id="subnetId",
                            weighted_capacity=123
                        )]
                    )],
                    load_balancers_config=ec2.CfnSpotFleet.LoadBalancersConfigProperty(
                        classic_load_balancers_config=ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty(
                            classic_load_balancers=[ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                                name="name"
                            )]
                        ),
                        target_groups_config=ec2.CfnSpotFleet.TargetGroupsConfigProperty(
                            target_groups=[ec2.CfnSpotFleet.TargetGroupProperty(
                                arn="arn"
                            )]
                        )
                    ),
                    on_demand_allocation_strategy="onDemandAllocationStrategy",
                    on_demand_max_total_price="onDemandMaxTotalPrice",
                    on_demand_target_capacity=123,
                    replace_unhealthy_instances=False,
                    spot_maintenance_strategies=ec2.CfnSpotFleet.SpotMaintenanceStrategiesProperty(
                        capacity_rebalance=ec2.CfnSpotFleet.SpotCapacityRebalanceProperty(
                            replacement_strategy="replacementStrategy",
                            termination_delay=123
                        )
                    ),
                    spot_max_total_price="spotMaxTotalPrice",
                    spot_price="spotPrice",
                    tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                        resource_type="resourceType",
                        tags=[CfnTag(
                            key="key",
                            value="value"
                        )]
                    )],
                    target_capacity_unit_type="targetCapacityUnitType",
                    terminate_instances_with_expiration=False,
                    type="type",
                    valid_from="validFrom",
                    valid_until="validUntil"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__96e39e67c39e4d79142080d6f0ca11d1deb92976c2e01dbf2167274e9004285d)
                check_type(argname="argument iam_fleet_role", value=iam_fleet_role, expected_type=type_hints["iam_fleet_role"])
                check_type(argname="argument target_capacity", value=target_capacity, expected_type=type_hints["target_capacity"])
                check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
                check_type(argname="argument context", value=context, expected_type=type_hints["context"])
                check_type(argname="argument excess_capacity_termination_policy", value=excess_capacity_termination_policy, expected_type=type_hints["excess_capacity_termination_policy"])
                check_type(argname="argument instance_interruption_behavior", value=instance_interruption_behavior, expected_type=type_hints["instance_interruption_behavior"])
                check_type(argname="argument instance_pools_to_use_count", value=instance_pools_to_use_count, expected_type=type_hints["instance_pools_to_use_count"])
                check_type(argname="argument launch_specifications", value=launch_specifications, expected_type=type_hints["launch_specifications"])
                check_type(argname="argument launch_template_configs", value=launch_template_configs, expected_type=type_hints["launch_template_configs"])
                check_type(argname="argument load_balancers_config", value=load_balancers_config, expected_type=type_hints["load_balancers_config"])
                check_type(argname="argument on_demand_allocation_strategy", value=on_demand_allocation_strategy, expected_type=type_hints["on_demand_allocation_strategy"])
                check_type(argname="argument on_demand_max_total_price", value=on_demand_max_total_price, expected_type=type_hints["on_demand_max_total_price"])
                check_type(argname="argument on_demand_target_capacity", value=on_demand_target_capacity, expected_type=type_hints["on_demand_target_capacity"])
                check_type(argname="argument replace_unhealthy_instances", value=replace_unhealthy_instances, expected_type=type_hints["replace_unhealthy_instances"])
                check_type(argname="argument spot_maintenance_strategies", value=spot_maintenance_strategies, expected_type=type_hints["spot_maintenance_strategies"])
                check_type(argname="argument spot_max_total_price", value=spot_max_total_price, expected_type=type_hints["spot_max_total_price"])
                check_type(argname="argument spot_price", value=spot_price, expected_type=type_hints["spot_price"])
                check_type(argname="argument tag_specifications", value=tag_specifications, expected_type=type_hints["tag_specifications"])
                check_type(argname="argument target_capacity_unit_type", value=target_capacity_unit_type, expected_type=type_hints["target_capacity_unit_type"])
                check_type(argname="argument terminate_instances_with_expiration", value=terminate_instances_with_expiration, expected_type=type_hints["terminate_instances_with_expiration"])
                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
                check_type(argname="argument valid_from", value=valid_from, expected_type=type_hints["valid_from"])
                check_type(argname="argument valid_until", value=valid_until, expected_type=type_hints["valid_until"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "iam_fleet_role": iam_fleet_role,
                "target_capacity": target_capacity,
            }
            if allocation_strategy is not None:
                self._values["allocation_strategy"] = allocation_strategy
            if context is not None:
                self._values["context"] = context
            if excess_capacity_termination_policy is not None:
                self._values["excess_capacity_termination_policy"] = excess_capacity_termination_policy
            if instance_interruption_behavior is not None:
                self._values["instance_interruption_behavior"] = instance_interruption_behavior
            if instance_pools_to_use_count is not None:
                self._values["instance_pools_to_use_count"] = instance_pools_to_use_count
            if launch_specifications is not None:
                self._values["launch_specifications"] = launch_specifications
            if launch_template_configs is not None:
                self._values["launch_template_configs"] = launch_template_configs
            if load_balancers_config is not None:
                self._values["load_balancers_config"] = load_balancers_config
            if on_demand_allocation_strategy is not None:
                self._values["on_demand_allocation_strategy"] = on_demand_allocation_strategy
            if on_demand_max_total_price is not None:
                self._values["on_demand_max_total_price"] = on_demand_max_total_price
            if on_demand_target_capacity is not None:
                self._values["on_demand_target_capacity"] = on_demand_target_capacity
            if replace_unhealthy_instances is not None:
                self._values["replace_unhealthy_instances"] = replace_unhealthy_instances
            if spot_maintenance_strategies is not None:
                self._values["spot_maintenance_strategies"] = spot_maintenance_strategies
            if spot_max_total_price is not None:
                self._values["spot_max_total_price"] = spot_max_total_price
            if spot_price is not None:
                self._values["spot_price"] = spot_price
            if tag_specifications is not None:
                self._values["tag_specifications"] = tag_specifications
            if target_capacity_unit_type is not None:
                self._values["target_capacity_unit_type"] = target_capacity_unit_type
            if terminate_instances_with_expiration is not None:
                self._values["terminate_instances_with_expiration"] = terminate_instances_with_expiration
            if type is not None:
                self._values["type"] = type
            if valid_from is not None:
                self._values["valid_from"] = valid_from
            if valid_until is not None:
                self._values["valid_until"] = valid_until

        @builtins.property
        def iam_fleet_role(self) -> builtins.str:
            '''The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants the Spot Fleet the permission to request, launch, terminate, and tag instances on your behalf.

            For more information, see `Spot Fleet Prerequisites <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html#spot-fleet-prerequisites>`_ in the *Amazon EC2 User Guide for Linux Instances* . Spot Fleet can terminate Spot Instances on your behalf when you cancel its Spot Fleet request or when the Spot Fleet request expires, if you set ``TerminateInstancesWithExpiration`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-iamfleetrole
            '''
            result = self._values.get("iam_fleet_role")
            assert result is not None, "Required property 'iam_fleet_role' is missing"
            return typing.cast(builtins.str, result)

        @builtins.property
        def target_capacity(self) -> jsii.Number:
            '''The number of units to request for the Spot Fleet.

            You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is ``maintain`` , you can specify a target capacity of 0 and add capacity later.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-targetcapacity
            '''
            result = self._values.get("target_capacity")
            assert result is not None, "Required property 'target_capacity' is missing"
            return typing.cast(jsii.Number, result)

        @builtins.property
        def allocation_strategy(self) -> typing.Optional[builtins.str]:
            '''The strategy that determines how to allocate the target Spot Instance capacity across the Spot Instance pools specified by the Spot Fleet launch configuration.

            For more information, see `Allocation strategies for Spot Instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-allocation-strategy.html>`_ in the *Amazon EC2 User Guide* .

            - **priceCapacityOptimized (recommended)** - Spot Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. Spot Fleet then requests Spot Instances from the lowest priced of these pools.
            - **capacityOptimized** - Spot Fleet identifies the pools with the highest capacity availability for the number of instances that are launching. This means that we will request Spot Instances from the pools that we believe have the lowest chance of interruption in the near term. To give certain instance types a higher chance of launching first, use ``capacityOptimizedPrioritized`` . Set a priority for each instance type by using the ``Priority`` parameter for ``LaunchTemplateOverrides`` . You can assign the same priority to different ``LaunchTemplateOverrides`` . EC2 implements the priorities on a best-effort basis, but optimizes for capacity first. ``capacityOptimizedPrioritized`` is supported only if your Spot Fleet uses a launch template. Note that if the ``OnDemandAllocationStrategy`` is set to ``prioritized`` , the same priority is applied when fulfilling On-Demand capacity.
            - **diversified** - Spot Fleet requests instances from all of the Spot Instance pools that you specify.
            - **lowestPrice** - Spot Fleet requests instances from the lowest priced Spot Instance pool that has available capacity. If the lowest priced pool doesn't have available capacity, the Spot Instances come from the next lowest priced pool that has available capacity. If a pool runs out of capacity before fulfilling your desired capacity, Spot Fleet will continue to fulfill your request by drawing from the next lowest priced pool. To ensure that your desired capacity is met, you might receive Spot Instances from several pools. Because this strategy only considers instance price and not capacity availability, it might lead to high interruption rates.

            Default: ``lowestPrice``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-allocationstrategy
            '''
            result = self._values.get("allocation_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def context(self) -> typing.Optional[builtins.str]:
            '''Reserved.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-context
            '''
            result = self._values.get("context")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def excess_capacity_termination_policy(self) -> typing.Optional[builtins.str]:
            '''Indicates whether running Spot Instances should be terminated if you decrease the target capacity of the Spot Fleet request below the current size of the Spot Fleet.

            Supported only for fleets of type ``maintain`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-excesscapacityterminationpolicy
            '''
            result = self._values.get("excess_capacity_termination_policy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_interruption_behavior(self) -> typing.Optional[builtins.str]:
            '''The behavior when a Spot Instance is interrupted.

            The default is ``terminate`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-instanceinterruptionbehavior
            '''
            result = self._values.get("instance_interruption_behavior")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def instance_pools_to_use_count(self) -> typing.Optional[jsii.Number]:
            '''The number of Spot pools across which to allocate your target Spot capacity.

            Valid only when Spot *AllocationStrategy* is set to ``lowest-price`` . Spot Fleet selects the cheapest Spot pools and evenly allocates your target Spot capacity across the number of Spot pools that you specify.

            Note that Spot Fleet attempts to draw Spot Instances from the number of pools that you specify on a best effort basis. If a pool runs out of Spot capacity before fulfilling your target capacity, Spot Fleet will continue to fulfill your request by drawing from the next cheapest pool. To ensure that your target capacity is met, you might receive Spot Instances from more than the number of pools that you specified. Similarly, if most of the pools have no Spot capacity, you might receive your full target capacity from fewer than the number of pools that you specified.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-instancepoolstousecount
            '''
            result = self._values.get("instance_pools_to_use_count")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def launch_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetLaunchSpecificationProperty"]]]]:
            '''The launch specifications for the Spot Fleet request.

            If you specify ``LaunchSpecifications`` , you can't specify ``LaunchTemplateConfigs`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-launchspecifications
            '''
            result = self._values.get("launch_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetLaunchSpecificationProperty"]]]], result)

        @builtins.property
        def launch_template_configs(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LaunchTemplateConfigProperty"]]]]:
            '''The launch template and overrides.

            If you specify ``LaunchTemplateConfigs`` , you can't specify ``LaunchSpecifications`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-launchtemplateconfigs
            '''
            result = self._values.get("launch_template_configs")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LaunchTemplateConfigProperty"]]]], result)

        @builtins.property
        def load_balancers_config(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LoadBalancersConfigProperty"]]:
            '''One or more Classic Load Balancers and target groups to attach to the Spot Fleet request.

            Spot Fleet registers the running Spot Instances with the specified Classic Load Balancers and target groups.

            With Network Load Balancers, Spot Fleet cannot register instances that have the following instance types: C1, CC1, CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, HS1, M1, M2, M3, and T1.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-loadbalancersconfig
            '''
            result = self._values.get("load_balancers_config")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.LoadBalancersConfigProperty"]], result)

        @builtins.property
        def on_demand_allocation_strategy(self) -> typing.Optional[builtins.str]:
            '''The order of the launch template overrides to use in fulfilling On-Demand capacity.

            If you specify ``lowestPrice`` , Spot Fleet uses price to determine the order, launching the lowest price first. If you specify ``prioritized`` , Spot Fleet uses the priority that you assign to each Spot Fleet launch template override, launching the highest priority first. If you do not specify a value, Spot Fleet defaults to ``lowestPrice`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-ondemandallocationstrategy
            '''
            result = self._values.get("on_demand_allocation_strategy")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def on_demand_max_total_price(self) -> typing.Optional[builtins.str]:
            '''The maximum amount per hour for On-Demand Instances that you're willing to pay.

            You can use the ``onDemandMaxTotalPrice`` parameter, the ``spotMaxTotalPrice`` parameter, or both parameters to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, Spot Fleet will launch instances until it reaches the maximum amount you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity.
            .. epigraph::

               If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``onDemandMaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``onDemandMaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-ondemandmaxtotalprice
            '''
            result = self._values.get("on_demand_max_total_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def on_demand_target_capacity(self) -> typing.Optional[jsii.Number]:
            '''The number of On-Demand units to request.

            You can choose to set the target capacity in terms of instances or a performance characteristic that is important to your application workload, such as vCPUs, memory, or I/O. If the request type is ``maintain`` , you can specify a target capacity of 0 and add capacity later.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-ondemandtargetcapacity
            '''
            result = self._values.get("on_demand_target_capacity")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def replace_unhealthy_instances(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether Spot Fleet should replace unhealthy instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-replaceunhealthyinstances
            '''
            result = self._values.get("replace_unhealthy_instances")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def spot_maintenance_strategies(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotMaintenanceStrategiesProperty"]]:
            '''The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-spotmaintenancestrategies
            '''
            result = self._values.get("spot_maintenance_strategies")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotMaintenanceStrategiesProperty"]], result)

        @builtins.property
        def spot_max_total_price(self) -> typing.Optional[builtins.str]:
            '''The maximum amount per hour for Spot Instances that you're willing to pay.

            You can use the ``spotMaxTotalPrice`` parameter, the ``onDemandMaxTotalPrice`` parameter, or both parameters to ensure that your fleet cost does not exceed your budget. If you set a maximum price per hour for the On-Demand Instances and Spot Instances in your request, Spot Fleet will launch instances until it reaches the maximum amount you're willing to pay. When the maximum amount you're willing to pay is reached, the fleet stops launching instances even if it hasn’t met the target capacity.
            .. epigraph::

               If your fleet includes T instances that are configured as ``unlimited`` , and if their average CPU usage exceeds the baseline utilization, you will incur a charge for surplus credits. The ``spotMaxTotalPrice`` does not account for surplus credits, and, if you use surplus credits, your final cost might be higher than what you specified for ``spotMaxTotalPrice`` . For more information, see `Surplus credits can incur charges <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode-concepts.html#unlimited-mode-surplus-credits>`_ in the *EC2 User Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-spotmaxtotalprice
            '''
            result = self._values.get("spot_max_total_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def spot_price(self) -> typing.Optional[builtins.str]:
            '''The maximum price per unit hour that you are willing to pay for a Spot Instance.

            We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.
            .. epigraph::

               If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-spotprice
            '''
            result = self._values.get("spot_price")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tag_specifications(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetTagSpecificationProperty"]]]]:
            '''The key-value pair for tagging the Spot Fleet request on creation.

            The value for ``ResourceType`` must be ``spot-fleet-request`` , otherwise the Spot Fleet request fails. To tag instances at launch, specify the tags in the `launch template <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template>`_ (valid only if you use ``LaunchTemplateConfigs`` ) or in the ``[SpotFleetTagSpecification](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetTagSpecification.html)`` (valid only if you use ``LaunchSpecifications`` ). For information about tagging after launch, see `Tag your resources <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-resources>`_ .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-tagspecifications
            '''
            result = self._values.get("tag_specifications")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotFleetTagSpecificationProperty"]]]], result)

        @builtins.property
        def target_capacity_unit_type(self) -> typing.Optional[builtins.str]:
            '''The unit for the target capacity. You can specify this parameter only when using attribute-based instance type selection.

            Default: ``units`` (the number of instances)

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-targetcapacityunittype
            '''
            result = self._values.get("target_capacity_unit_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def terminate_instances_with_expiration(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether running Spot Instances are terminated when the Spot Fleet request expires.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-terminateinstanceswithexpiration
            '''
            result = self._values.get("terminate_instances_with_expiration")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def type(self) -> typing.Optional[builtins.str]:
            '''The type of request.

            Indicates whether the Spot Fleet only requests the target capacity or also attempts to maintain it. When this value is ``request`` , the Spot Fleet only places the required requests. It does not attempt to replenish Spot Instances if capacity is diminished, nor does it submit requests in alternative Spot pools if capacity is not available. When this value is ``maintain`` , the Spot Fleet maintains the target capacity. The Spot Fleet places the required requests to meet capacity and automatically replenishes any interrupted instances. Default: ``maintain`` . ``instant`` is listed but is not used by Spot Fleet.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-type
            '''
            result = self._values.get("type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def valid_from(self) -> typing.Optional[builtins.str]:
            '''The start date and time of the request, in UTC format ( *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).

            By default, Amazon EC2 starts fulfilling the request immediately.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-validfrom
            '''
            result = self._values.get("valid_from")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def valid_until(self) -> typing.Optional[builtins.str]:
            '''The end date and time of the request, in UTC format ( *YYYY* - *MM* - *DD* T *HH* : *MM* : *SS* Z).

            After the end date and time, no new Spot Instance requests are placed or able to fulfill the request. If no value is specified, the Spot Fleet request remains until you cancel it.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleetrequestconfigdata.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata-validuntil
            '''
            result = self._values.get("valid_until")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotFleetRequestConfigDataProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={"resource_type": "resourceType", "tags": "tags"},
    )
    class SpotFleetTagSpecificationProperty:
        def __init__(
            self,
            *,
            resource_type: typing.Optional[builtins.str] = None,
            tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The tags for a Spot Fleet resource.

            :param resource_type: The type of resource. Currently, the only resource type that is supported is ``instance`` . To tag the Spot Fleet request on creation, use the ``TagSpecifications`` parameter in ``[SpotFleetRequestConfigData](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html)`` .
            :param tags: The tags.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleettagspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_fleet_tag_specification_property = ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                    resource_type="resourceType",
                    tags=[CfnTag(
                        key="key",
                        value="value"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__0f35f2896caa0167d6333a92f1df926b97081f631b578435e4340f30e78b1bca)
                check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if resource_type is not None:
                self._values["resource_type"] = resource_type
            if tags is not None:
                self._values["tags"] = tags

        @builtins.property
        def resource_type(self) -> typing.Optional[builtins.str]:
            '''The type of resource.

            Currently, the only resource type that is supported is ``instance`` . To tag the Spot Fleet request on creation, use the ``TagSpecifications`` parameter in ``[SpotFleetRequestConfigData](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetRequestConfigData.html)`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleettagspecification.html#cfn-ec2-spotfleet-spotfleettagspecification-resourcetype
            '''
            result = self._values.get("resource_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
            '''The tags.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotfleettagspecification.html#cfn-ec2-spotfleet-spotfleettagspecification-tags
            '''
            result = self._values.get("tags")
            return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotFleetTagSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotMaintenanceStrategiesProperty",
        jsii_struct_bases=[],
        name_mapping={"capacity_rebalance": "capacityRebalance"},
    )
    class SpotMaintenanceStrategiesProperty:
        def __init__(
            self,
            *,
            capacity_rebalance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.SpotCapacityRebalanceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''The strategies for managing your Spot Instances that are at an elevated risk of being interrupted.

            :param capacity_rebalance: The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted. For more information, see `Capacity rebalancing <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotmaintenancestrategies.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_maintenance_strategies_property = ec2.CfnSpotFleet.SpotMaintenanceStrategiesProperty(
                    capacity_rebalance=ec2.CfnSpotFleet.SpotCapacityRebalanceProperty(
                        replacement_strategy="replacementStrategy",
                        termination_delay=123
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__358912d3da8f0ef48490d3fcfc7e7d25ac4bb9de14819d26fc6b0dac8f2cefb0)
                check_type(argname="argument capacity_rebalance", value=capacity_rebalance, expected_type=type_hints["capacity_rebalance"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if capacity_rebalance is not None:
                self._values["capacity_rebalance"] = capacity_rebalance

        @builtins.property
        def capacity_rebalance(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotCapacityRebalanceProperty"]]:
            '''The Spot Instance replacement strategy to use when Amazon EC2 emits a signal that your Spot Instance is at an elevated risk of being interrupted.

            For more information, see `Capacity rebalancing <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-capacity-rebalance.html>`_ in the *Amazon EC2 User Guide for Linux Instances* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotmaintenancestrategies.html#cfn-ec2-spotfleet-spotmaintenancestrategies-capacityrebalance
            '''
            result = self._values.get("capacity_rebalance")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.SpotCapacityRebalanceProperty"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotMaintenanceStrategiesProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.SpotPlacementProperty",
        jsii_struct_bases=[],
        name_mapping={
            "availability_zone": "availabilityZone",
            "group_name": "groupName",
            "tenancy": "tenancy",
        },
    )
    class SpotPlacementProperty:
        def __init__(
            self,
            *,
            availability_zone: typing.Optional[builtins.str] = None,
            group_name: typing.Optional[builtins.str] = None,
            tenancy: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes Spot Instance placement.

            :param availability_zone: The Availability Zone. To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".
            :param group_name: The name of the placement group.
            :param tenancy: The tenancy of the instance (if the instance is running in a VPC). An instance with a tenancy of ``dedicated`` runs on single-tenant hardware. The ``host`` tenancy is not supported for Spot Instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotplacement.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                spot_placement_property = ec2.CfnSpotFleet.SpotPlacementProperty(
                    availability_zone="availabilityZone",
                    group_name="groupName",
                    tenancy="tenancy"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__bfa50300dd4a5a936d14fd7c5333917be6259780cff3172591f4c4bb46066959)
                check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
                check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
                check_type(argname="argument tenancy", value=tenancy, expected_type=type_hints["tenancy"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if availability_zone is not None:
                self._values["availability_zone"] = availability_zone
            if group_name is not None:
                self._values["group_name"] = group_name
            if tenancy is not None:
                self._values["tenancy"] = tenancy

        @builtins.property
        def availability_zone(self) -> typing.Optional[builtins.str]:
            '''The Availability Zone.

            To specify multiple Availability Zones, separate them using commas; for example, "us-west-2a, us-west-2b".

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotplacement.html#cfn-ec2-spotfleet-spotplacement-availabilityzone
            '''
            result = self._values.get("availability_zone")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def group_name(self) -> typing.Optional[builtins.str]:
            '''The name of the placement group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotplacement.html#cfn-ec2-spotfleet-spotplacement-groupname
            '''
            result = self._values.get("group_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tenancy(self) -> typing.Optional[builtins.str]:
            '''The tenancy of the instance (if the instance is running in a VPC).

            An instance with a tenancy of ``dedicated`` runs on single-tenant hardware. The ``host`` tenancy is not supported for Spot Instances.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-spotplacement.html#cfn-ec2-spotfleet-spotplacement-tenancy
            '''
            result = self._values.get("tenancy")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SpotPlacementProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.TargetGroupProperty",
        jsii_struct_bases=[],
        name_mapping={"arn": "arn"},
    )
    class TargetGroupProperty:
        def __init__(self, *, arn: builtins.str) -> None:
            '''Describes a load balancer target group.

            :param arn: The Amazon Resource Name (ARN) of the target group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-targetgroup.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                target_group_property = ec2.CfnSpotFleet.TargetGroupProperty(
                    arn="arn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__cfcb40128ba9ae2ad293302d89e5aa4a53c03cf29c409d83d0e67338adff73ec)
                check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "arn": arn,
            }

        @builtins.property
        def arn(self) -> builtins.str:
            '''The Amazon Resource Name (ARN) of the target group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-targetgroup.html#cfn-ec2-spotfleet-targetgroup-arn
            '''
            result = self._values.get("arn")
            assert result is not None, "Required property 'arn' is missing"
            return typing.cast(builtins.str, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TargetGroupProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.TargetGroupsConfigProperty",
        jsii_struct_bases=[],
        name_mapping={"target_groups": "targetGroups"},
    )
    class TargetGroupsConfigProperty:
        def __init__(
            self,
            *,
            target_groups: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnSpotFleet.TargetGroupProperty", typing.Dict[builtins.str, typing.Any]]]]],
        ) -> None:
            '''Describes the target groups to attach to a Spot Fleet.

            Spot Fleet registers the running Spot Instances with these target groups.

            :param target_groups: One or more target groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-targetgroupsconfig.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                target_groups_config_property = ec2.CfnSpotFleet.TargetGroupsConfigProperty(
                    target_groups=[ec2.CfnSpotFleet.TargetGroupProperty(
                        arn="arn"
                    )]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__8c745b802ed9970f7336f102ee634cf183cd84857b9f739bab7e9b66f7ddc4a3)
                check_type(argname="argument target_groups", value=target_groups, expected_type=type_hints["target_groups"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "target_groups": target_groups,
            }

        @builtins.property
        def target_groups(
            self,
        ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TargetGroupProperty"]]]:
            '''One or more target groups.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-targetgroupsconfig.html#cfn-ec2-spotfleet-targetgroupsconfig-targetgroups
            '''
            result = self._values.get("target_groups")
            assert result is not None, "Required property 'target_groups' is missing"
            return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnSpotFleet.TargetGroupProperty"]]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TargetGroupsConfigProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class TotalLocalStorageGBRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum amount of total local storage, in GB.

            :param max: The maximum amount of total local storage, in GB. To specify no maximum limit, omit this parameter.
            :param min: The minimum amount of total local storage, in GB. To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-totallocalstoragegbrequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                total_local_storage_gBRequest_property = ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__06acf1d43569866b4e132737f9c0f5dc5a8fb8a951ab042576f2122de8f80e6d)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum amount of total local storage, in GB.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-totallocalstoragegbrequest.html#cfn-ec2-spotfleet-totallocalstoragegbrequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum amount of total local storage, in GB.

            To specify no minimum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-totallocalstoragegbrequest.html#cfn-ec2-spotfleet-totallocalstoragegbrequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TotalLocalStorageGBRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleet.VCpuCountRangeRequestProperty",
        jsii_struct_bases=[],
        name_mapping={"max": "max", "min": "min"},
    )
    class VCpuCountRangeRequestProperty:
        def __init__(
            self,
            *,
            max: typing.Optional[jsii.Number] = None,
            min: typing.Optional[jsii.Number] = None,
        ) -> None:
            '''The minimum and maximum number of vCPUs.

            :param max: The maximum number of vCPUs. To specify no maximum limit, omit this parameter.
            :param min: The minimum number of vCPUs. To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-vcpucountrangerequest.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                v_cpu_count_range_request_property = ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                    max=123,
                    min=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__cd3a984fe26c96a263a4ba0c4b1343feb154e583aa8ce45faba1dfa139f1b05c)
                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if max is not None:
                self._values["max"] = max
            if min is not None:
                self._values["min"] = min

        @builtins.property
        def max(self) -> typing.Optional[jsii.Number]:
            '''The maximum number of vCPUs.

            To specify no maximum limit, omit this parameter.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-vcpucountrangerequest.html#cfn-ec2-spotfleet-vcpucountrangerequest-max
            '''
            result = self._values.get("max")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def min(self) -> typing.Optional[jsii.Number]:
            '''The minimum number of vCPUs.

            To specify no minimum limit, specify ``0`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-spotfleet-vcpucountrangerequest.html#cfn-ec2-spotfleet-vcpucountrangerequest-min
            '''
            result = self._values.get("min")
            return typing.cast(typing.Optional[jsii.Number], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VCpuCountRangeRequestProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSpotFleetProps",
    jsii_struct_bases=[],
    name_mapping={"spot_fleet_request_config_data": "spotFleetRequestConfigData"},
)
class CfnSpotFleetProps:
    def __init__(
        self,
        *,
        spot_fleet_request_config_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetRequestConfigDataProperty, typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''Properties for defining a ``CfnSpotFleet``.

        :param spot_fleet_request_config_data: Describes the configuration of a Spot Fleet request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-spotfleet.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_spot_fleet_props = ec2.CfnSpotFleetProps(
                spot_fleet_request_config_data=ec2.CfnSpotFleet.SpotFleetRequestConfigDataProperty(
                    iam_fleet_role="iamFleetRole",
                    target_capacity=123,
            
                    # the properties below are optional
                    allocation_strategy="allocationStrategy",
                    context="context",
                    excess_capacity_termination_policy="excessCapacityTerminationPolicy",
                    instance_interruption_behavior="instanceInterruptionBehavior",
                    instance_pools_to_use_count=123,
                    launch_specifications=[ec2.CfnSpotFleet.SpotFleetLaunchSpecificationProperty(
                        image_id="imageId",
            
                        # the properties below are optional
                        block_device_mappings=[ec2.CfnSpotFleet.BlockDeviceMappingProperty(
                            device_name="deviceName",
            
                            # the properties below are optional
                            ebs=ec2.CfnSpotFleet.EbsBlockDeviceProperty(
                                delete_on_termination=False,
                                encrypted=False,
                                iops=123,
                                snapshot_id="snapshotId",
                                volume_size=123,
                                volume_type="volumeType"
                            ),
                            no_device="noDevice",
                            virtual_name="virtualName"
                        )],
                        ebs_optimized=False,
                        iam_instance_profile=ec2.CfnSpotFleet.IamInstanceProfileSpecificationProperty(
                            arn="arn"
                        ),
                        instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                            accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_manufacturers=["acceleratorManufacturers"],
                            accelerator_names=["acceleratorNames"],
                            accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            accelerator_types=["acceleratorTypes"],
                            allowed_instance_types=["allowedInstanceTypes"],
                            bare_metal="bareMetal",
                            baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            burstable_performance="burstablePerformance",
                            cpu_manufacturers=["cpuManufacturers"],
                            excluded_instance_types=["excludedInstanceTypes"],
                            instance_generations=["instanceGenerations"],
                            local_storage="localStorage",
                            local_storage_types=["localStorageTypes"],
                            memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                max=123,
                                min=123
                            ),
                            memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                max=123,
                                min=123
                            ),
                            network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                max=123,
                                min=123
                            ),
                            on_demand_max_price_percentage_over_lowest_price=123,
                            require_hibernate_support=False,
                            spot_max_price_percentage_over_lowest_price=123,
                            total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                max=123,
                                min=123
                            ),
                            v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                max=123,
                                min=123
                            )
                        ),
                        instance_type="instanceType",
                        kernel_id="kernelId",
                        key_name="keyName",
                        monitoring=ec2.CfnSpotFleet.SpotFleetMonitoringProperty(
                            enabled=False
                        ),
                        network_interfaces=[ec2.CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty(
                            associate_public_ip_address=False,
                            delete_on_termination=False,
                            description="description",
                            device_index=123,
                            groups=["groups"],
                            ipv6_address_count=123,
                            ipv6_addresses=[ec2.CfnSpotFleet.InstanceIpv6AddressProperty(
                                ipv6_address="ipv6Address"
                            )],
                            network_interface_id="networkInterfaceId",
                            private_ip_addresses=[ec2.CfnSpotFleet.PrivateIpAddressSpecificationProperty(
                                private_ip_address="privateIpAddress",
            
                                # the properties below are optional
                                primary=False
                            )],
                            secondary_private_ip_address_count=123,
                            subnet_id="subnetId"
                        )],
                        placement=ec2.CfnSpotFleet.SpotPlacementProperty(
                            availability_zone="availabilityZone",
                            group_name="groupName",
                            tenancy="tenancy"
                        ),
                        ramdisk_id="ramdiskId",
                        security_groups=[ec2.CfnSpotFleet.GroupIdentifierProperty(
                            group_id="groupId"
                        )],
                        spot_price="spotPrice",
                        subnet_id="subnetId",
                        tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                            resource_type="resourceType",
                            tags=[CfnTag(
                                key="key",
                                value="value"
                            )]
                        )],
                        user_data="userData",
                        weighted_capacity=123
                    )],
                    launch_template_configs=[ec2.CfnSpotFleet.LaunchTemplateConfigProperty(
                        launch_template_specification=ec2.CfnSpotFleet.FleetLaunchTemplateSpecificationProperty(
                            version="version",
            
                            # the properties below are optional
                            launch_template_id="launchTemplateId",
                            launch_template_name="launchTemplateName"
                        ),
                        overrides=[ec2.CfnSpotFleet.LaunchTemplateOverridesProperty(
                            availability_zone="availabilityZone",
                            instance_requirements=ec2.CfnSpotFleet.InstanceRequirementsRequestProperty(
                                accelerator_count=ec2.CfnSpotFleet.AcceleratorCountRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                accelerator_manufacturers=["acceleratorManufacturers"],
                                accelerator_names=["acceleratorNames"],
                                accelerator_total_memory_mi_b=ec2.CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                accelerator_types=["acceleratorTypes"],
                                allowed_instance_types=["allowedInstanceTypes"],
                                bare_metal="bareMetal",
                                baseline_ebs_bandwidth_mbps=ec2.CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                burstable_performance="burstablePerformance",
                                cpu_manufacturers=["cpuManufacturers"],
                                excluded_instance_types=["excludedInstanceTypes"],
                                instance_generations=["instanceGenerations"],
                                local_storage="localStorage",
                                local_storage_types=["localStorageTypes"],
                                memory_gi_bPer_vCpu=ec2.CfnSpotFleet.MemoryGiBPerVCpuRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                memory_mi_b=ec2.CfnSpotFleet.MemoryMiBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                network_bandwidth_gbps=ec2.CfnSpotFleet.NetworkBandwidthGbpsRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                network_interface_count=ec2.CfnSpotFleet.NetworkInterfaceCountRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                on_demand_max_price_percentage_over_lowest_price=123,
                                require_hibernate_support=False,
                                spot_max_price_percentage_over_lowest_price=123,
                                total_local_storage_gb=ec2.CfnSpotFleet.TotalLocalStorageGBRequestProperty(
                                    max=123,
                                    min=123
                                ),
                                v_cpu_count=ec2.CfnSpotFleet.VCpuCountRangeRequestProperty(
                                    max=123,
                                    min=123
                                )
                            ),
                            instance_type="instanceType",
                            priority=123,
                            spot_price="spotPrice",
                            subnet_id="subnetId",
                            weighted_capacity=123
                        )]
                    )],
                    load_balancers_config=ec2.CfnSpotFleet.LoadBalancersConfigProperty(
                        classic_load_balancers_config=ec2.CfnSpotFleet.ClassicLoadBalancersConfigProperty(
                            classic_load_balancers=[ec2.CfnSpotFleet.ClassicLoadBalancerProperty(
                                name="name"
                            )]
                        ),
                        target_groups_config=ec2.CfnSpotFleet.TargetGroupsConfigProperty(
                            target_groups=[ec2.CfnSpotFleet.TargetGroupProperty(
                                arn="arn"
                            )]
                        )
                    ),
                    on_demand_allocation_strategy="onDemandAllocationStrategy",
                    on_demand_max_total_price="onDemandMaxTotalPrice",
                    on_demand_target_capacity=123,
                    replace_unhealthy_instances=False,
                    spot_maintenance_strategies=ec2.CfnSpotFleet.SpotMaintenanceStrategiesProperty(
                        capacity_rebalance=ec2.CfnSpotFleet.SpotCapacityRebalanceProperty(
                            replacement_strategy="replacementStrategy",
                            termination_delay=123
                        )
                    ),
                    spot_max_total_price="spotMaxTotalPrice",
                    spot_price="spotPrice",
                    tag_specifications=[ec2.CfnSpotFleet.SpotFleetTagSpecificationProperty(
                        resource_type="resourceType",
                        tags=[CfnTag(
                            key="key",
                            value="value"
                        )]
                    )],
                    target_capacity_unit_type="targetCapacityUnitType",
                    terminate_instances_with_expiration=False,
                    type="type",
                    valid_from="validFrom",
                    valid_until="validUntil"
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9ba1dd409c9f6c2b307a2662c74f48716ccd437f87094831130aa4d0f583a5c1)
            check_type(argname="argument spot_fleet_request_config_data", value=spot_fleet_request_config_data, expected_type=type_hints["spot_fleet_request_config_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "spot_fleet_request_config_data": spot_fleet_request_config_data,
        }

    @builtins.property
    def spot_fleet_request_config_data(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, CfnSpotFleet.SpotFleetRequestConfigDataProperty]:
        '''Describes the configuration of a Spot Fleet request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-spotfleet.html#cfn-ec2-spotfleet-spotfleetrequestconfigdata
        '''
        result = self._values.get("spot_fleet_request_config_data")
        assert result is not None, "Required property 'spot_fleet_request_config_data' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnSpotFleet.SpotFleetRequestConfigDataProperty], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSpotFleetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnSubnet(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnet",
):
    '''Specifies a subnet for the specified VPC.

    For an IPv4 only subnet, specify an IPv4 CIDR block. If the VPC has an IPv6 CIDR block, you can create an IPv6 only subnet or a dual stack subnet instead. For an IPv6 only subnet, specify an IPv6 CIDR block. For a dual stack subnet, specify both an IPv4 CIDR block and an IPv6 CIDR block.

    For more information, see `Subnets for your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html
    :cloudformationResource: AWS::EC2::Subnet
    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        def associate_subnet_with_v6_cidr(self, vpc, count, subnet):
            cfn_subnet = subnet.node.default_child
            cfn_subnet.ipv6_cidr_block = Fn.select(count, Fn.cidr(Fn.select(0, vpc.vpc_ipv6_cidr_blocks), 256, (128 - 64).to_string()))
            cfn_subnet.assign_ipv6_address_on_creation = True
        
        # make an ipv6 cidr
        ipv6cidr = ec2.CfnVPCCidrBlock(self, "CIDR6",
            vpc_id=vpc.vpc_id,
            amazon_provided_ipv6_cidr_block=True
        )
        
        # connect the ipv6 cidr to all vpc subnets
        subnetcount = 0
        subnets = vpc.public_subnets.concat(vpc.private_subnets)
        for subnet in subnets:
            # Wait for the ipv6 cidr to complete
            subnet.node.add_dependency(ipv6cidr)
            associate_subnet_with_v6_cidr(vpc, subnetcount, subnet)
            subnetcount = subnetcount + 1
        
        cluster = eks.Cluster(self, "hello-eks",
            version=eks.KubernetesVersion.V1_29,
            vpc=vpc,
            ip_family=eks.IpFamily.IP_V6,
            vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        availability_zone_id: typing.Optional[builtins.str] = None,
        cidr_block: typing.Optional[builtins.str] = None,
        enable_dns64: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_native: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
        map_public_ip_on_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
        private_dns_name_options_on_launch: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC the subnet is in. If you update this property, you must also update the ``CidrBlock`` property.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. The default value is ``false`` . If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.
        :param availability_zone: The Availability Zone of the subnet. If you update this property, you must also update the ``CidrBlock`` property.
        :param availability_zone_id: The AZ ID of the subnet.
        :param cidr_block: The IPv4 CIDR block assigned to the subnet. If you update this property, we create a new subnet, and then delete the existing one.
        :param enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see `DNS64 and NAT64 <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64>`_ in the *Amazon Virtual Private Cloud User Guide* .
        :param ipv4_ipam_pool_id: An IPv4 IPAM pool ID for the subnet.
        :param ipv4_netmask_length: An IPv4 netmask length for the subnet.
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.
        :param ipv6_cidr_blocks: The IPv6 network ranges for the subnet, in CIDR notation.
        :param ipv6_ipam_pool_id: An IPv6 IPAM pool ID for the subnet.
        :param ipv6_native: Indicates whether this is an IPv6 only subnet. For more information, see `Subnet basics <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#subnet-basics>`_ in the *Amazon Virtual Private Cloud User Guide* .
        :param ipv6_netmask_length: An IPv6 netmask length for the subnet.
        :param map_public_ip_on_launch: Indicates whether instances launched in this subnet receive a public IPv4 address. The default value is ``false`` . AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .
        :param outpost_arn: The Amazon Resource Name (ARN) of the Outpost.
        :param private_dns_name_options_on_launch: The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries to the instances should be handled. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . Available options: - EnableResourceNameDnsAAAARecord (true | false) - EnableResourceNameDnsARecord (true | false) - HostnameType (ip-name | resource-name)
        :param tags: Any tags assigned to the subnet.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3552c7996fe8d37a6b035d9a3032e8c21e885c6d2abd5a0f9ff377ae3a0ecf57)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSubnetProps(
            vpc_id=vpc_id,
            assign_ipv6_address_on_creation=assign_ipv6_address_on_creation,
            availability_zone=availability_zone,
            availability_zone_id=availability_zone_id,
            cidr_block=cidr_block,
            enable_dns64=enable_dns64,
            ipv4_ipam_pool_id=ipv4_ipam_pool_id,
            ipv4_netmask_length=ipv4_netmask_length,
            ipv6_cidr_block=ipv6_cidr_block,
            ipv6_cidr_blocks=ipv6_cidr_blocks,
            ipv6_ipam_pool_id=ipv6_ipam_pool_id,
            ipv6_native=ipv6_native,
            ipv6_netmask_length=ipv6_netmask_length,
            map_public_ip_on_launch=map_public_ip_on_launch,
            outpost_arn=outpost_arn,
            private_dns_name_options_on_launch=private_dns_name_options_on_launch,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6156a193ebc4d0f9f0b05548058061d243acb636c512c72051b309b52a9f9eaa)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab21bad99e8fed59878de9a3c0dff4a9b147ea44572c7f6e3fb94c9ccdd5b5f7)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAvailabilityZone")
    def attr_availability_zone(self) -> builtins.str:
        '''The Availability Zone of this subnet.

        For example, ``us-east-1a`` .

        :cloudformationAttribute: AvailabilityZone
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="attrAvailabilityZoneId")
    def attr_availability_zone_id(self) -> builtins.str:
        '''The Availability Zone ID of this subnet.

        For example, ``use1-az1`` .

        :cloudformationAttribute: AvailabilityZoneId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAvailabilityZoneId"))

    @builtins.property
    @jsii.member(jsii_name="attrCidrBlock")
    def attr_cidr_block(self) -> builtins.str:
        '''The IPv4 CIDR blocks that are associated with the subnet.

        :cloudformationAttribute: CidrBlock
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="attrIpv6CidrBlocks")
    def attr_ipv6_cidr_blocks(self) -> typing.List[builtins.str]:
        '''
        :cloudformationAttribute: Ipv6CidrBlocks
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrIpv6CidrBlocks"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkAclAssociationId")
    def attr_network_acl_association_id(self) -> builtins.str:
        '''The ID of the network ACL that is associated with the subnet's VPC, such as ``acl-5fb85d36`` .

        :cloudformationAttribute: NetworkAclAssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrNetworkAclAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="attrOutpostArn")
    def attr_outpost_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the Outpost.

        :cloudformationAttribute: OutpostArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOutpostArn"))

    @builtins.property
    @jsii.member(jsii_name="attrSubnetId")
    def attr_subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :cloudformationAttribute: SubnetId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSubnetId"))

    @builtins.property
    @jsii.member(jsii_name="attrVpcId")
    def attr_vpc_id(self) -> builtins.str:
        '''The ID of the subnet's VPC, such as ``vpc-11ad4878`` .

        :cloudformationAttribute: VpcId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpcId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC the subnet is in.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aad08d53a3fa5bb493bacf8cb9e5444c7c29dfdbb7ddbf9edf8e698012de854e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="assignIpv6AddressOnCreation")
    def assign_ipv6_address_on_creation(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether a network interface created in this subnet receives an IPv6 address.

        The default value is ``false`` .
        '''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "assignIpv6AddressOnCreation"))

    @assign_ipv6_address_on_creation.setter
    def assign_ipv6_address_on_creation(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__749bdee9b76dfa9816b5a3125fb8ff25ffab41bfe67e30d6997e6c906f70c8f5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "assignIpv6AddressOnCreation", value)

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone of the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "availabilityZone"))

    @availability_zone.setter
    def availability_zone(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d61c6c66cfcff863e99730d3fadecd08739afc1e6fe72df9f8a02ef3a30e4931)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZone", value)

    @builtins.property
    @jsii.member(jsii_name="availabilityZoneId")
    def availability_zone_id(self) -> typing.Optional[builtins.str]:
        '''The AZ ID of the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "availabilityZoneId"))

    @availability_zone_id.setter
    def availability_zone_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f88760ade883243269d5a16afd27db07d159b6822400158d977bee60187cba60)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZoneId", value)

    @builtins.property
    @jsii.member(jsii_name="cidrBlock")
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR block assigned to the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrBlock"))

    @cidr_block.setter
    def cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc4da08e39eed40a229643cb7d351ca4ddb8969c310ff4a588bf2f9b2c57ea2b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="enableDns64")
    def enable_dns64(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "enableDns64"))

    @enable_dns64.setter
    def enable_dns64(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08fffdbcd6d1db1ed3c089b63fe6c0aa0846d345c3d53724dd0545885b023517)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enableDns64", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4IpamPoolId")
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv4 IPAM pool ID for the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv4IpamPoolId"))

    @ipv4_ipam_pool_id.setter
    def ipv4_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e1b0157b33b156c98fb389fde191897914b633e753380d212dced9fb14a5522)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4NetmaskLength")
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv4 netmask length for the subnet.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv4NetmaskLength"))

    @ipv4_netmask_length.setter
    def ipv4_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed3081732b603fcc8ec9ebb9564e406e2e7472952031d76660f9757518d8e0ad)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4NetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6CidrBlock")
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6CidrBlock"))

    @ipv6_cidr_block.setter
    def ipv6_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32cbba39a8e77a22a9b46de57faddcc0bd138b522049dcc5b72fae1f010dcb6a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6CidrBlocks")
    def ipv6_cidr_blocks(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv6 network ranges for the subnet, in CIDR notation.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ipv6CidrBlocks"))

    @ipv6_cidr_blocks.setter
    def ipv6_cidr_blocks(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2924466543968587848b6c9a3abb9e410e42b51b663f080070f7b608ec34461f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6CidrBlocks", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6IpamPoolId")
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv6 IPAM pool ID for the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6IpamPoolId"))

    @ipv6_ipam_pool_id.setter
    def ipv6_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7d9766dde41d5681123bb5654fa95ff2d630c4e00a04381c5cfb0a75bb33ab6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6Native")
    def ipv6_native(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether this is an IPv6 only subnet.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "ipv6Native"))

    @ipv6_native.setter
    def ipv6_native(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fa8e8ff9fd2c1d32daaa28eaaf1a657bbae65ac881e2d64fae17cd5620a8bb2a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6Native", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6NetmaskLength")
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv6 netmask length for the subnet.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6NetmaskLength"))

    @ipv6_netmask_length.setter
    def ipv6_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79c0c96a0563a13bc67d2000e0d23b07922c04c49b66b0f017a1d3750266a111)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6NetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="mapPublicIpOnLaunch")
    def map_public_ip_on_launch(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether instances launched in this subnet receive a public IPv4 address.

        The default value is ``false`` .
        '''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "mapPublicIpOnLaunch"))

    @map_public_ip_on_launch.setter
    def map_public_ip_on_launch(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1176c1fa68c8c764e85625e34f7177136204be31a2b8e4fddc47f3513120b75c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "mapPublicIpOnLaunch", value)

    @builtins.property
    @jsii.member(jsii_name="outpostArn")
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "outpostArn"))

    @outpost_arn.setter
    def outpost_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1411603d4698ad667b7aec511028a02a96d43e8378e3f1f2300b1c77c6b00fc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "outpostArn", value)

    @builtins.property
    @jsii.member(jsii_name="privateDnsNameOptionsOnLaunch")
    def private_dns_name_options_on_launch(self) -> typing.Any:
        '''The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries to the instances should be handled.'''
        return typing.cast(typing.Any, jsii.get(self, "privateDnsNameOptionsOnLaunch"))

    @private_dns_name_options_on_launch.setter
    def private_dns_name_options_on_launch(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e13366cee6d454131332273c13879e73090bba06a29c362064c8fb55fa666614)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateDnsNameOptionsOnLaunch", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the subnet.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b297663d31b5bbe92a3f56911eb6c57abab4c122a855b348cb1da68bcf50efe3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnSubnet.PrivateDnsNameOptionsOnLaunchProperty",
        jsii_struct_bases=[],
        name_mapping={
            "enable_resource_name_dns_aaaa_record": "enableResourceNameDnsAaaaRecord",
            "enable_resource_name_dns_a_record": "enableResourceNameDnsARecord",
            "hostname_type": "hostnameType",
        },
    )
    class PrivateDnsNameOptionsOnLaunchProperty:
        def __init__(
            self,
            *,
            enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            hostname_type: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the options for instance hostnames.

            :param enable_resource_name_dns_aaaa_record: Indicates whether to respond to DNS queries for instance hostname with DNS AAAA records.
            :param enable_resource_name_dns_a_record: Indicates whether to respond to DNS queries for instance hostnames with DNS A records.
            :param hostname_type: The type of hostname for EC2 instances. For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-privatednsnameoptionsonlaunch.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                private_dns_name_options_on_launch_property = ec2.CfnSubnet.PrivateDnsNameOptionsOnLaunchProperty(
                    enable_resource_name_dns_aaaa_record=False,
                    enable_resource_name_dns_aRecord=False,
                    hostname_type="hostnameType"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9ead2dbf33a2462f22ec4fe1b542f6a0fc766e914575dd0c8da36b35e6a471a0)
                check_type(argname="argument enable_resource_name_dns_aaaa_record", value=enable_resource_name_dns_aaaa_record, expected_type=type_hints["enable_resource_name_dns_aaaa_record"])
                check_type(argname="argument enable_resource_name_dns_a_record", value=enable_resource_name_dns_a_record, expected_type=type_hints["enable_resource_name_dns_a_record"])
                check_type(argname="argument hostname_type", value=hostname_type, expected_type=type_hints["hostname_type"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enable_resource_name_dns_aaaa_record is not None:
                self._values["enable_resource_name_dns_aaaa_record"] = enable_resource_name_dns_aaaa_record
            if enable_resource_name_dns_a_record is not None:
                self._values["enable_resource_name_dns_a_record"] = enable_resource_name_dns_a_record
            if hostname_type is not None:
                self._values["hostname_type"] = hostname_type

        @builtins.property
        def enable_resource_name_dns_aaaa_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostname with DNS AAAA records.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-privatednsnameoptionsonlaunch.html#cfn-ec2-subnet-privatednsnameoptionsonlaunch-enableresourcenamednsaaaarecord
            '''
            result = self._values.get("enable_resource_name_dns_aaaa_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def enable_resource_name_dns_a_record(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to respond to DNS queries for instance hostnames with DNS A records.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-privatednsnameoptionsonlaunch.html#cfn-ec2-subnet-privatednsnameoptionsonlaunch-enableresourcenamednsarecord
            '''
            result = self._values.get("enable_resource_name_dns_a_record")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def hostname_type(self) -> typing.Optional[builtins.str]:
            '''The type of hostname for EC2 instances.

            For IPv4 only subnets, an instance DNS name must be based on the instance IPv4 address. For IPv6 only subnets, an instance DNS name must be based on the instance ID. For dual-stack subnets, you can specify whether DNS names use the instance IPv4 address or the instance ID.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-privatednsnameoptionsonlaunch.html#cfn-ec2-subnet-privatednsnameoptionsonlaunch-hostnametype
            '''
            result = self._values.get("hostname_type")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PrivateDnsNameOptionsOnLaunchProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnSubnetCidrBlock(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetCidrBlock",
):
    '''Associates a CIDR block with your subnet.

    You can associate a single IPv6 CIDR block with your subnet.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html
    :cloudformationResource: AWS::EC2::SubnetCidrBlock
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_subnet_cidr_block = ec2.CfnSubnetCidrBlock(self, "MyCfnSubnetCidrBlock",
            subnet_id="subnetId",
        
            # the properties below are optional
            ipv6_cidr_block="ipv6CidrBlock",
            ipv6_ipam_pool_id="ipv6IpamPoolId",
            ipv6_netmask_length=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_id: The ID of the subnet.
        :param ipv6_cidr_block: The IPv6 network range for the subnet, in CIDR notation.
        :param ipv6_ipam_pool_id: An IPv6 IPAM pool ID for the subnet.
        :param ipv6_netmask_length: An IPv6 netmask length for the subnet.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cea972c46cc6b50f26ade1aeb13ea8427be0dcee4ec5ef424ab06a54f974851)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSubnetCidrBlockProps(
            subnet_id=subnet_id,
            ipv6_cidr_block=ipv6_cidr_block,
            ipv6_ipam_pool_id=ipv6_ipam_pool_id,
            ipv6_netmask_length=ipv6_netmask_length,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__81545e5ad3988b846e1a2818225195a63d3d514916d75bd48e2c13c7bed235e3)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7748afe0f6471ee19ab5901ad409f669a3f3faf2ff7a9355b237ccef73272a4c)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the association.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4efd57f93a642c14210500623dadba0a052ecf5f63cdd81b7da1517c743193fe)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6CidrBlock")
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 network range for the subnet, in CIDR notation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6CidrBlock"))

    @ipv6_cidr_block.setter
    def ipv6_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8a93fcd23cf2bfc75bc22656ab89fb6faf4261d84c2b56613bfcd5f45f8d8c17)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6IpamPoolId")
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv6 IPAM pool ID for the subnet.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6IpamPoolId"))

    @ipv6_ipam_pool_id.setter
    def ipv6_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__47bacd49bbd20a576e8606ed6d9c47edfc3f6de53d74312f66482bd773de9e93)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6NetmaskLength")
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv6 netmask length for the subnet.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6NetmaskLength"))

    @ipv6_netmask_length.setter
    def ipv6_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__452e13bfbef96c8acd7605d4b366122948a9d1a1a6ea7aa8f96dab339baea0d9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6NetmaskLength", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetCidrBlockProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "ipv6_ipam_pool_id": "ipv6IpamPoolId",
        "ipv6_netmask_length": "ipv6NetmaskLength",
    },
)
class CfnSubnetCidrBlockProps:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnSubnetCidrBlock``.

        :param subnet_id: The ID of the subnet.
        :param ipv6_cidr_block: The IPv6 network range for the subnet, in CIDR notation.
        :param ipv6_ipam_pool_id: An IPv6 IPAM pool ID for the subnet.
        :param ipv6_netmask_length: An IPv6 netmask length for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_subnet_cidr_block_props = ec2.CfnSubnetCidrBlockProps(
                subnet_id="subnetId",
            
                # the properties below are optional
                ipv6_cidr_block="ipv6CidrBlock",
                ipv6_ipam_pool_id="ipv6IpamPoolId",
                ipv6_netmask_length=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__921910fa5abf704ffe5d8790c2dc76e78950fd3fb2bf752eed76bf90f1024b87)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument ipv6_ipam_pool_id", value=ipv6_ipam_pool_id, expected_type=type_hints["ipv6_ipam_pool_id"])
            check_type(argname="argument ipv6_netmask_length", value=ipv6_netmask_length, expected_type=type_hints["ipv6_netmask_length"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if ipv6_ipam_pool_id is not None:
            self._values["ipv6_ipam_pool_id"] = ipv6_ipam_pool_id
        if ipv6_netmask_length is not None:
            self._values["ipv6_netmask_length"] = ipv6_netmask_length

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html#cfn-ec2-subnetcidrblock-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 network range for the subnet, in CIDR notation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html#cfn-ec2-subnetcidrblock-ipv6cidrblock
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv6 IPAM pool ID for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html#cfn-ec2-subnetcidrblock-ipv6ipampoolid
        '''
        result = self._values.get("ipv6_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv6 netmask length for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetcidrblock.html#cfn-ec2-subnetcidrblock-ipv6netmasklength
        '''
        result = self._values.get("ipv6_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSubnetCidrBlockProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnSubnetNetworkAclAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetNetworkAclAssociation",
):
    '''Associates a subnet with a network ACL. For more information, see `ReplaceNetworkAclAssociation <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceNetworkAclAssociation.html>`_ in the *Amazon EC2 API Reference* .

    When ``AWS::EC2::SubnetNetworkAclAssociation`` resources are created during create or update operations, AWS CloudFormation adopts existing resources that share the same key properties (the properties that contribute to uniquely identify the resource). However, if the operation fails and rolls back, AWS CloudFormation deletes the previously out-of-band resources. You can protect against this behavior by using ``Retain`` deletion policies. For more information, see `DeletionPolicy Attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetnetworkaclassociation.html
    :cloudformationResource: AWS::EC2::SubnetNetworkAclAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_subnet_network_acl_association = ec2.CfnSubnetNetworkAclAssociation(self, "MyCfnSubnetNetworkAclAssociation",
            network_acl_id="networkAclId",
            subnet_id="subnetId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_acl_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param network_acl_id: The ID of the network ACL.
        :param subnet_id: The ID of the subnet.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85259f8a3e99ac9118a42a8d47888848ef4038d0875782d7999e412d88e08e49)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSubnetNetworkAclAssociationProps(
            network_acl_id=network_acl_id, subnet_id=subnet_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfcd7cfb671f801b9900bd757e22bf2ef004eae956d3db39783c929e666c99a1)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46741ae4382fe5da17191998ae3a27c6d9d2f7aa50f33a2c9d63bc5ca20ebd0f)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAssociationId")
    def attr_association_id(self) -> builtins.str:
        '''Returns the value of this object's AssociationId property.

        :cloudformationAttribute: AssociationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="networkAclId")
    def network_acl_id(self) -> builtins.str:
        '''The ID of the network ACL.'''
        return typing.cast(builtins.str, jsii.get(self, "networkAclId"))

    @network_acl_id.setter
    def network_acl_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5cf968b4e7c1d6097c91b50633033f355376ba0c50b179c88b61b64419ac35f5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkAclId", value)

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__20de455202a2a20f984202966e9bd377f01da603283f59078646c968d52ec14a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetNetworkAclAssociationProps",
    jsii_struct_bases=[],
    name_mapping={"network_acl_id": "networkAclId", "subnet_id": "subnetId"},
)
class CfnSubnetNetworkAclAssociationProps:
    def __init__(
        self,
        *,
        network_acl_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnSubnetNetworkAclAssociation``.

        :param network_acl_id: The ID of the network ACL.
        :param subnet_id: The ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetnetworkaclassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_subnet_network_acl_association_props = ec2.CfnSubnetNetworkAclAssociationProps(
                network_acl_id="networkAclId",
                subnet_id="subnetId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c0946d220fda59f06b2de56a738afbe1371347d6dca68f5b624f6c01802e1320)
            check_type(argname="argument network_acl_id", value=network_acl_id, expected_type=type_hints["network_acl_id"])
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_acl_id": network_acl_id,
            "subnet_id": subnet_id,
        }

    @builtins.property
    def network_acl_id(self) -> builtins.str:
        '''The ID of the network ACL.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetnetworkaclassociation.html#cfn-ec2-subnetnetworkaclassociation-networkaclid
        '''
        result = self._values.get("network_acl_id")
        assert result is not None, "Required property 'network_acl_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetnetworkaclassociation.html#cfn-ec2-subnetnetworkaclassociation-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSubnetNetworkAclAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc_id": "vpcId",
        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
        "availability_zone": "availabilityZone",
        "availability_zone_id": "availabilityZoneId",
        "cidr_block": "cidrBlock",
        "enable_dns64": "enableDns64",
        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
        "ipv4_netmask_length": "ipv4NetmaskLength",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "ipv6_cidr_blocks": "ipv6CidrBlocks",
        "ipv6_ipam_pool_id": "ipv6IpamPoolId",
        "ipv6_native": "ipv6Native",
        "ipv6_netmask_length": "ipv6NetmaskLength",
        "map_public_ip_on_launch": "mapPublicIpOnLaunch",
        "outpost_arn": "outpostArn",
        "private_dns_name_options_on_launch": "privateDnsNameOptionsOnLaunch",
        "tags": "tags",
    },
)
class CfnSubnetProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        availability_zone_id: typing.Optional[builtins.str] = None,
        cidr_block: typing.Optional[builtins.str] = None,
        enable_dns64: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_native: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
        map_public_ip_on_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
        private_dns_name_options_on_launch: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnSubnet``.

        :param vpc_id: The ID of the VPC the subnet is in. If you update this property, you must also update the ``CidrBlock`` property.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. The default value is ``false`` . If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.
        :param availability_zone: The Availability Zone of the subnet. If you update this property, you must also update the ``CidrBlock`` property.
        :param availability_zone_id: The AZ ID of the subnet.
        :param cidr_block: The IPv4 CIDR block assigned to the subnet. If you update this property, we create a new subnet, and then delete the existing one.
        :param enable_dns64: Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations. For more information, see `DNS64 and NAT64 <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64>`_ in the *Amazon Virtual Private Cloud User Guide* .
        :param ipv4_ipam_pool_id: An IPv4 IPAM pool ID for the subnet.
        :param ipv4_netmask_length: An IPv4 netmask length for the subnet.
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.
        :param ipv6_cidr_blocks: The IPv6 network ranges for the subnet, in CIDR notation.
        :param ipv6_ipam_pool_id: An IPv6 IPAM pool ID for the subnet.
        :param ipv6_native: Indicates whether this is an IPv6 only subnet. For more information, see `Subnet basics <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#subnet-basics>`_ in the *Amazon Virtual Private Cloud User Guide* .
        :param ipv6_netmask_length: An IPv6 netmask length for the subnet.
        :param map_public_ip_on_launch: Indicates whether instances launched in this subnet receive a public IPv4 address. The default value is ``false`` . AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .
        :param outpost_arn: The Amazon Resource Name (ARN) of the Outpost.
        :param private_dns_name_options_on_launch: The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries to the instances should be handled. For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . Available options: - EnableResourceNameDnsAAAARecord (true | false) - EnableResourceNameDnsARecord (true | false) - HostnameType (ip-name | resource-name)
        :param tags: Any tags assigned to the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # private_dns_name_options_on_launch: Any
            
            cfn_subnet_props = ec2.CfnSubnetProps(
                vpc_id="vpcId",
            
                # the properties below are optional
                assign_ipv6_address_on_creation=False,
                availability_zone="availabilityZone",
                availability_zone_id="availabilityZoneId",
                cidr_block="cidrBlock",
                enable_dns64=False,
                ipv4_ipam_pool_id="ipv4IpamPoolId",
                ipv4_netmask_length=123,
                ipv6_cidr_block="ipv6CidrBlock",
                ipv6_cidr_blocks=["ipv6CidrBlocks"],
                ipv6_ipam_pool_id="ipv6IpamPoolId",
                ipv6_native=False,
                ipv6_netmask_length=123,
                map_public_ip_on_launch=False,
                outpost_arn="outpostArn",
                private_dns_name_options_on_launch=private_dns_name_options_on_launch,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35feab8ee8f0aeb1dcb5a7eb3df1cde58a61806467c8cc5f249b6acf5c54da22)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument assign_ipv6_address_on_creation", value=assign_ipv6_address_on_creation, expected_type=type_hints["assign_ipv6_address_on_creation"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument availability_zone_id", value=availability_zone_id, expected_type=type_hints["availability_zone_id"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument enable_dns64", value=enable_dns64, expected_type=type_hints["enable_dns64"])
            check_type(argname="argument ipv4_ipam_pool_id", value=ipv4_ipam_pool_id, expected_type=type_hints["ipv4_ipam_pool_id"])
            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument ipv6_cidr_blocks", value=ipv6_cidr_blocks, expected_type=type_hints["ipv6_cidr_blocks"])
            check_type(argname="argument ipv6_ipam_pool_id", value=ipv6_ipam_pool_id, expected_type=type_hints["ipv6_ipam_pool_id"])
            check_type(argname="argument ipv6_native", value=ipv6_native, expected_type=type_hints["ipv6_native"])
            check_type(argname="argument ipv6_netmask_length", value=ipv6_netmask_length, expected_type=type_hints["ipv6_netmask_length"])
            check_type(argname="argument map_public_ip_on_launch", value=map_public_ip_on_launch, expected_type=type_hints["map_public_ip_on_launch"])
            check_type(argname="argument outpost_arn", value=outpost_arn, expected_type=type_hints["outpost_arn"])
            check_type(argname="argument private_dns_name_options_on_launch", value=private_dns_name_options_on_launch, expected_type=type_hints["private_dns_name_options_on_launch"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if assign_ipv6_address_on_creation is not None:
            self._values["assign_ipv6_address_on_creation"] = assign_ipv6_address_on_creation
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if availability_zone_id is not None:
            self._values["availability_zone_id"] = availability_zone_id
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if enable_dns64 is not None:
            self._values["enable_dns64"] = enable_dns64
        if ipv4_ipam_pool_id is not None:
            self._values["ipv4_ipam_pool_id"] = ipv4_ipam_pool_id
        if ipv4_netmask_length is not None:
            self._values["ipv4_netmask_length"] = ipv4_netmask_length
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if ipv6_cidr_blocks is not None:
            self._values["ipv6_cidr_blocks"] = ipv6_cidr_blocks
        if ipv6_ipam_pool_id is not None:
            self._values["ipv6_ipam_pool_id"] = ipv6_ipam_pool_id
        if ipv6_native is not None:
            self._values["ipv6_native"] = ipv6_native
        if ipv6_netmask_length is not None:
            self._values["ipv6_netmask_length"] = ipv6_netmask_length
        if map_public_ip_on_launch is not None:
            self._values["map_public_ip_on_launch"] = map_public_ip_on_launch
        if outpost_arn is not None:
            self._values["outpost_arn"] = outpost_arn
        if private_dns_name_options_on_launch is not None:
            self._values["private_dns_name_options_on_launch"] = private_dns_name_options_on_launch
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC the subnet is in.

        If you update this property, you must also update the ``CidrBlock`` property.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def assign_ipv6_address_on_creation(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether a network interface created in this subnet receives an IPv6 address. The default value is ``false`` .

        If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-assignipv6addressoncreation
        '''
        result = self._values.get("assign_ipv6_address_on_creation")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone of the subnet.

        If you update this property, you must also update the ``CidrBlock`` property.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-availabilityzone
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def availability_zone_id(self) -> typing.Optional[builtins.str]:
        '''The AZ ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-availabilityzoneid
        '''
        result = self._values.get("availability_zone_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR block assigned to the subnet.

        If you update this property, we create a new subnet, and then delete the existing one.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-cidrblock
        '''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enable_dns64(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return synthetic IPv6 addresses for IPv4-only destinations.

        For more information, see `DNS64 and NAT64 <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-nat64-dns64>`_ in the *Amazon Virtual Private Cloud User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-enabledns64
        '''
        result = self._values.get("enable_dns64")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv4 IPAM pool ID for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv4ipampoolid
        '''
        result = self._values.get("ipv4_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv4 netmask length for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv4netmasklength
        '''
        result = self._values.get("ipv4_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block.

        If you specify ``AssignIpv6AddressOnCreation`` , you must also specify an IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv6cidrblock
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_cidr_blocks(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IPv6 network ranges for the subnet, in CIDR notation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv6cidrblocks
        '''
        result = self._values.get("ipv6_cidr_blocks")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''An IPv6 IPAM pool ID for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv6ipampoolid
        '''
        result = self._values.get("ipv6_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_native(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether this is an IPv6 only subnet.

        For more information, see `Subnet basics <https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#subnet-basics>`_ in the *Amazon Virtual Private Cloud User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv6native
        '''
        result = self._values.get("ipv6_native")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''An IPv6 netmask length for the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-ipv6netmasklength
        '''
        result = self._values.get("ipv6_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def map_public_ip_on_launch(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether instances launched in this subnet receive a public IPv4 address. The default value is ``false`` .

        AWS charges for all public IPv4 addresses, including public IPv4 addresses associated with running instances and Elastic IP addresses. For more information, see the *Public IPv4 Address* tab on the `VPC pricing page <https://docs.aws.amazon.com/vpc/pricing/>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-mappubliciponlaunch
        '''
        result = self._values.get("map_public_ip_on_launch")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-outpostarn
        '''
        result = self._values.get("outpost_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def private_dns_name_options_on_launch(self) -> typing.Any:
        '''The hostname type for EC2 instances launched into this subnet and how DNS A and AAAA record queries to the instances should be handled.

        For more information, see `Amazon EC2 instance hostname types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

        Available options:

        - EnableResourceNameDnsAAAARecord (true | false)
        - EnableResourceNameDnsARecord (true | false)
        - HostnameType (ip-name | resource-name)

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-privatednsnameoptionsonlaunch
        '''
        result = self._values.get("private_dns_name_options_on_launch")
        return typing.cast(typing.Any, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSubnetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnSubnetRouteTableAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetRouteTableAssociation",
):
    '''Associates a subnet with a route table.

    The subnet and route table must be in the same VPC. This association causes traffic originating from the subnet to be routed according to the routes in the route table. A route table can be associated with multiple subnets. To create a route table, see `AWS::EC2::RouteTable <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-routetable.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetroutetableassociation.html
    :cloudformationResource: AWS::EC2::SubnetRouteTableAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_subnet_route_table_association = ec2.CfnSubnetRouteTableAssociation(self, "MyCfnSubnetRouteTableAssociation",
            route_table_id="routeTableId",
            subnet_id="subnetId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        route_table_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param route_table_id: The ID of the route table. The physical ID changes when the route table ID is changed.
        :param subnet_id: The ID of the subnet.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__294c1e9f851a710b52055c4f95268b2eb5d074c4d171e81323e769d40fa7aa03)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnSubnetRouteTableAssociationProps(
            route_table_id=route_table_id, subnet_id=subnet_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ffbed3c635301c3dd5e86e308c08d9a18b5a7b7b9854af76a0205620cd2a9e00)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22bcaee54b84824fa37f45bc532da947376d35a559b7f05c9f82232096b07dd1)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the subnet route table association.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="routeTableId")
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table.'''
        return typing.cast(builtins.str, jsii.get(self, "routeTableId"))

    @route_table_id.setter
    def route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b81a44aa8082896b06b0d035fdae44f5a718c027db2e512155192468e0f69c0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "routeTableId", value)

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dc32529a14292116d1c9386ba1f02c8787852edc420a39b64cc810ef446c60dc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnSubnetRouteTableAssociationProps",
    jsii_struct_bases=[],
    name_mapping={"route_table_id": "routeTableId", "subnet_id": "subnetId"},
)
class CfnSubnetRouteTableAssociationProps:
    def __init__(
        self,
        *,
        route_table_id: builtins.str,
        subnet_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnSubnetRouteTableAssociation``.

        :param route_table_id: The ID of the route table. The physical ID changes when the route table ID is changed.
        :param subnet_id: The ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetroutetableassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_subnet_route_table_association_props = ec2.CfnSubnetRouteTableAssociationProps(
                route_table_id="routeTableId",
                subnet_id="subnetId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__59925cd44b90933fc24031ecd6f926df6d2d62b0406726dd75f11833681a80db)
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "route_table_id": route_table_id,
            "subnet_id": subnet_id,
        }

    @builtins.property
    def route_table_id(self) -> builtins.str:
        '''The ID of the route table.

        The physical ID changes when the route table ID is changed.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetroutetableassociation.html#cfn-ec2-subnetroutetableassociation-routetableid
        '''
        result = self._values.get("route_table_id")
        assert result is not None, "Required property 'route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnetroutetableassociation.html#cfn-ec2-subnetroutetableassociation-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnSubnetRouteTableAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTrafficMirrorFilter(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorFilter",
):
    '''Specifies a Traffic Mirror filter.

    A Traffic Mirror filter is a set of rules that defines the traffic to mirror.

    By default, no traffic is mirrored. To mirror traffic, use `AWS::EC2::TrafficMirrorFilterRule <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html>`_ to add Traffic Mirror rules to the filter. The rules you add define what traffic gets mirrored.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilter.html
    :cloudformationResource: AWS::EC2::TrafficMirrorFilter
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_traffic_mirror_filter = ec2.CfnTrafficMirrorFilter(self, "MyCfnTrafficMirrorFilter",
            description="description",
            network_services=["networkServices"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        network_services: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param description: The description of the Traffic Mirror filter.
        :param network_services: The network service traffic that is associated with the Traffic Mirror filter. Valid values are ``amazon-dns`` .
        :param tags: The tags to assign to a Traffic Mirror filter.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3010c8c23523308b937b13bf2fd061ce50421e19e699a33715927ea747a36fe)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTrafficMirrorFilterProps(
            description=description, network_services=network_services, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4139de6cf862ad5d74c52e241eee09962b6e2d2983b38ee7d69d9fa4f3e2626e)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9796f7c469044aefb3cc59e55ef7c9fffbac54c39bfa4d37ab4526f3c451b021)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror filter.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34c87f41e67e3d2c9ece9a99826b4a349e6793112061a31f7e0d295aa75c9bea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="networkServices")
    def network_services(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The network service traffic that is associated with the Traffic Mirror filter.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "networkServices"))

    @network_services.setter
    def network_services(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e14bdc88434e1d710881affb7ac0701cafd52b3833e3a79e069b66fa0adb72f4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkServices", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to a Traffic Mirror filter.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f1c9440946dad085b634913583179ecc95e0af8128310eb6f018e4709297712f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorFilterProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "network_services": "networkServices",
        "tags": "tags",
    },
)
class CfnTrafficMirrorFilterProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        network_services: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTrafficMirrorFilter``.

        :param description: The description of the Traffic Mirror filter.
        :param network_services: The network service traffic that is associated with the Traffic Mirror filter. Valid values are ``amazon-dns`` .
        :param tags: The tags to assign to a Traffic Mirror filter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilter.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_traffic_mirror_filter_props = ec2.CfnTrafficMirrorFilterProps(
                description="description",
                network_services=["networkServices"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc240768174256167e14afa8be2711f58bc36134a0a78ff17c568c834caed61d)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument network_services", value=network_services, expected_type=type_hints["network_services"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if network_services is not None:
            self._values["network_services"] = network_services
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror filter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilter.html#cfn-ec2-trafficmirrorfilter-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_services(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The network service traffic that is associated with the Traffic Mirror filter.

        Valid values are ``amazon-dns`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilter.html#cfn-ec2-trafficmirrorfilter-networkservices
        '''
        result = self._values.get("network_services")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to a Traffic Mirror filter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilter.html#cfn-ec2-trafficmirrorfilter-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTrafficMirrorFilterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnTrafficMirrorFilterRule(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorFilterRule",
):
    '''Creates a Traffic Mirror filter rule.

    A Traffic Mirror rule defines the Traffic Mirror source traffic to mirror.

    You need the Traffic Mirror filter ID when you create the rule.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html
    :cloudformationResource: AWS::EC2::TrafficMirrorFilterRule
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_traffic_mirror_filter_rule = ec2.CfnTrafficMirrorFilterRule(self, "MyCfnTrafficMirrorFilterRule",
            destination_cidr_block="destinationCidrBlock",
            rule_action="ruleAction",
            rule_number=123,
            source_cidr_block="sourceCidrBlock",
            traffic_direction="trafficDirection",
            traffic_mirror_filter_id="trafficMirrorFilterId",
        
            # the properties below are optional
            description="description",
            destination_port_range=ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty(
                from_port=123,
                to_port=123
            ),
            protocol=123,
            source_port_range=ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty(
                from_port=123,
                to_port=123
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        destination_cidr_block: builtins.str,
        rule_action: builtins.str,
        rule_number: jsii.Number,
        source_cidr_block: builtins.str,
        traffic_direction: builtins.str,
        traffic_mirror_filter_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        protocol: typing.Optional[jsii.Number] = None,
        source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param destination_cidr_block: The destination CIDR block to assign to the Traffic Mirror rule.
        :param rule_action: The action to take on the filtered traffic.
        :param rule_number: The number of the Traffic Mirror rule. This number must be unique for each Traffic Mirror rule in a given direction. The rules are processed in ascending order by rule number.
        :param source_cidr_block: The source CIDR block to assign to the Traffic Mirror rule.
        :param traffic_direction: The type of traffic.
        :param traffic_mirror_filter_id: The ID of the filter that this rule is associated with.
        :param description: The description of the Traffic Mirror rule.
        :param destination_port_range: The destination port range.
        :param protocol: The protocol, for example UDP, to assign to the Traffic Mirror rule. For information about the protocol value, see `Protocol Numbers <https://docs.aws.amazon.com/https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ on the Internet Assigned Numbers Authority (IANA) website.
        :param source_port_range: The source port range.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d31a4a58c039ce2bbc135b28c273cf97fb8d472640a28e00ca448193911be99)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTrafficMirrorFilterRuleProps(
            destination_cidr_block=destination_cidr_block,
            rule_action=rule_action,
            rule_number=rule_number,
            source_cidr_block=source_cidr_block,
            traffic_direction=traffic_direction,
            traffic_mirror_filter_id=traffic_mirror_filter_id,
            description=description,
            destination_port_range=destination_port_range,
            protocol=protocol,
            source_port_range=source_port_range,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__44d0755d06bfcb59329075440a91d3fd073045ea48cde80da24a13d27fcc4ace)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__530a255beefd02de60d367c9ac1d668826efee3c596db923d734ff2e5a007d47)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> builtins.str:
        '''The destination CIDR block to assign to the Traffic Mirror rule.'''
        return typing.cast(builtins.str, jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__453dc5a585f45610d480b3d9caac41d113f3861c3984c740384a3f9b49017cff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="ruleAction")
    def rule_action(self) -> builtins.str:
        '''The action to take on the filtered traffic.'''
        return typing.cast(builtins.str, jsii.get(self, "ruleAction"))

    @rule_action.setter
    def rule_action(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39ae22e971058237f4c2b7a3c9b290cd06a9d634d0b9fbf10881c6447ba16534)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ruleAction", value)

    @builtins.property
    @jsii.member(jsii_name="ruleNumber")
    def rule_number(self) -> jsii.Number:
        '''The number of the Traffic Mirror rule.'''
        return typing.cast(jsii.Number, jsii.get(self, "ruleNumber"))

    @rule_number.setter
    def rule_number(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3dfdefe397e1b467a4cb10154878fb4e8b2a4992d1135f0e177f5955c7301c7b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ruleNumber", value)

    @builtins.property
    @jsii.member(jsii_name="sourceCidrBlock")
    def source_cidr_block(self) -> builtins.str:
        '''The source CIDR block to assign to the Traffic Mirror rule.'''
        return typing.cast(builtins.str, jsii.get(self, "sourceCidrBlock"))

    @source_cidr_block.setter
    def source_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12766b41bee664bd087eac1601526fefa89d9e302e018b00fd16a01d0a95120c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="trafficDirection")
    def traffic_direction(self) -> builtins.str:
        '''The type of traffic.'''
        return typing.cast(builtins.str, jsii.get(self, "trafficDirection"))

    @traffic_direction.setter
    def traffic_direction(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42efc440f02fbd964f45fdc23d5d014c1db094a539ea68f5618320149e3b23d7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trafficDirection", value)

    @builtins.property
    @jsii.member(jsii_name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> builtins.str:
        '''The ID of the filter that this rule is associated with.'''
        return typing.cast(builtins.str, jsii.get(self, "trafficMirrorFilterId"))

    @traffic_mirror_filter_id.setter
    def traffic_mirror_filter_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98515aecd50906470f8454a919491e01c343040591ae34b9e141b8c7a9dcbb97)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trafficMirrorFilterId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror rule.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__521df83e7440c469be09cf04526f690bac9ea4f5cce00bb63cb6afc0dfe5f410)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="destinationPortRange")
    def destination_port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]]:
        '''The destination port range.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]], jsii.get(self, "destinationPortRange"))

    @destination_port_range.setter
    def destination_port_range(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c8951d72c6da3ddb59a85b44d76acecb81a501942b46d41d45178190e8993c70)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationPortRange", value)

    @builtins.property
    @jsii.member(jsii_name="protocol")
    def protocol(self) -> typing.Optional[jsii.Number]:
        '''The protocol, for example UDP, to assign to the Traffic Mirror rule.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "protocol"))

    @protocol.setter
    def protocol(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7405e6b85e9ba2b1c567ca1522aa3048bd85acb3773d5cac79ed869a4da5a0fe)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "protocol", value)

    @builtins.property
    @jsii.member(jsii_name="sourcePortRange")
    def source_port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]]:
        '''The source port range.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]], jsii.get(self, "sourcePortRange"))

    @source_port_range.setter
    def source_port_range(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d40ca05dc02941bd4e8428fe96fbea734028207b51cc90b1db404cf019650b1c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourcePortRange", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty",
        jsii_struct_bases=[],
        name_mapping={"from_port": "fromPort", "to_port": "toPort"},
    )
    class TrafficMirrorPortRangeProperty:
        def __init__(self, *, from_port: jsii.Number, to_port: jsii.Number) -> None:
            '''Describes the Traffic Mirror port range.

            :param from_port: The start of the Traffic Mirror port range. This applies to the TCP and UDP protocols.
            :param to_port: The end of the Traffic Mirror port range. This applies to the TCP and UDP protocols.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-trafficmirrorfilterrule-trafficmirrorportrange.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                traffic_mirror_port_range_property = ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty(
                    from_port=123,
                    to_port=123
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__9be5e236a0a787f81c7a17c253ae7c6c2e21e13d93a6f55bd8a2d0a9e42cecef)
                check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
                check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
            self._values: typing.Dict[builtins.str, typing.Any] = {
                "from_port": from_port,
                "to_port": to_port,
            }

        @builtins.property
        def from_port(self) -> jsii.Number:
            '''The start of the Traffic Mirror port range.

            This applies to the TCP and UDP protocols.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-trafficmirrorfilterrule-trafficmirrorportrange.html#cfn-ec2-trafficmirrorfilterrule-trafficmirrorportrange-fromport
            '''
            result = self._values.get("from_port")
            assert result is not None, "Required property 'from_port' is missing"
            return typing.cast(jsii.Number, result)

        @builtins.property
        def to_port(self) -> jsii.Number:
            '''The end of the Traffic Mirror port range.

            This applies to the TCP and UDP protocols.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-trafficmirrorfilterrule-trafficmirrorportrange.html#cfn-ec2-trafficmirrorfilterrule-trafficmirrorportrange-toport
            '''
            result = self._values.get("to_port")
            assert result is not None, "Required property 'to_port' is missing"
            return typing.cast(jsii.Number, result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TrafficMirrorPortRangeProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorFilterRuleProps",
    jsii_struct_bases=[],
    name_mapping={
        "destination_cidr_block": "destinationCidrBlock",
        "rule_action": "ruleAction",
        "rule_number": "ruleNumber",
        "source_cidr_block": "sourceCidrBlock",
        "traffic_direction": "trafficDirection",
        "traffic_mirror_filter_id": "trafficMirrorFilterId",
        "description": "description",
        "destination_port_range": "destinationPortRange",
        "protocol": "protocol",
        "source_port_range": "sourcePortRange",
    },
)
class CfnTrafficMirrorFilterRuleProps:
    def __init__(
        self,
        *,
        destination_cidr_block: builtins.str,
        rule_action: builtins.str,
        rule_number: jsii.Number,
        source_cidr_block: builtins.str,
        traffic_direction: builtins.str,
        traffic_mirror_filter_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        protocol: typing.Optional[jsii.Number] = None,
        source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTrafficMirrorFilterRule``.

        :param destination_cidr_block: The destination CIDR block to assign to the Traffic Mirror rule.
        :param rule_action: The action to take on the filtered traffic.
        :param rule_number: The number of the Traffic Mirror rule. This number must be unique for each Traffic Mirror rule in a given direction. The rules are processed in ascending order by rule number.
        :param source_cidr_block: The source CIDR block to assign to the Traffic Mirror rule.
        :param traffic_direction: The type of traffic.
        :param traffic_mirror_filter_id: The ID of the filter that this rule is associated with.
        :param description: The description of the Traffic Mirror rule.
        :param destination_port_range: The destination port range.
        :param protocol: The protocol, for example UDP, to assign to the Traffic Mirror rule. For information about the protocol value, see `Protocol Numbers <https://docs.aws.amazon.com/https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ on the Internet Assigned Numbers Authority (IANA) website.
        :param source_port_range: The source port range.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_traffic_mirror_filter_rule_props = ec2.CfnTrafficMirrorFilterRuleProps(
                destination_cidr_block="destinationCidrBlock",
                rule_action="ruleAction",
                rule_number=123,
                source_cidr_block="sourceCidrBlock",
                traffic_direction="trafficDirection",
                traffic_mirror_filter_id="trafficMirrorFilterId",
            
                # the properties below are optional
                description="description",
                destination_port_range=ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty(
                    from_port=123,
                    to_port=123
                ),
                protocol=123,
                source_port_range=ec2.CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty(
                    from_port=123,
                    to_port=123
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6d4d280ff7b483a33d845d48221597161e1166fa2e705738c6aa067763329bc)
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument rule_action", value=rule_action, expected_type=type_hints["rule_action"])
            check_type(argname="argument rule_number", value=rule_number, expected_type=type_hints["rule_number"])
            check_type(argname="argument source_cidr_block", value=source_cidr_block, expected_type=type_hints["source_cidr_block"])
            check_type(argname="argument traffic_direction", value=traffic_direction, expected_type=type_hints["traffic_direction"])
            check_type(argname="argument traffic_mirror_filter_id", value=traffic_mirror_filter_id, expected_type=type_hints["traffic_mirror_filter_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument destination_port_range", value=destination_port_range, expected_type=type_hints["destination_port_range"])
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument source_port_range", value=source_port_range, expected_type=type_hints["source_port_range"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "destination_cidr_block": destination_cidr_block,
            "rule_action": rule_action,
            "rule_number": rule_number,
            "source_cidr_block": source_cidr_block,
            "traffic_direction": traffic_direction,
            "traffic_mirror_filter_id": traffic_mirror_filter_id,
        }
        if description is not None:
            self._values["description"] = description
        if destination_port_range is not None:
            self._values["destination_port_range"] = destination_port_range
        if protocol is not None:
            self._values["protocol"] = protocol
        if source_port_range is not None:
            self._values["source_port_range"] = source_port_range

    @builtins.property
    def destination_cidr_block(self) -> builtins.str:
        '''The destination CIDR block to assign to the Traffic Mirror rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        assert result is not None, "Required property 'destination_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rule_action(self) -> builtins.str:
        '''The action to take on the filtered traffic.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-ruleaction
        '''
        result = self._values.get("rule_action")
        assert result is not None, "Required property 'rule_action' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def rule_number(self) -> jsii.Number:
        '''The number of the Traffic Mirror rule.

        This number must be unique for each Traffic Mirror rule in a given direction. The rules are processed in ascending order by rule number.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-rulenumber
        '''
        result = self._values.get("rule_number")
        assert result is not None, "Required property 'rule_number' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def source_cidr_block(self) -> builtins.str:
        '''The source CIDR block to assign to the Traffic Mirror rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-sourcecidrblock
        '''
        result = self._values.get("source_cidr_block")
        assert result is not None, "Required property 'source_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def traffic_direction(self) -> builtins.str:
        '''The type of traffic.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-trafficdirection
        '''
        result = self._values.get("traffic_direction")
        assert result is not None, "Required property 'traffic_direction' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def traffic_mirror_filter_id(self) -> builtins.str:
        '''The ID of the filter that this rule is associated with.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-trafficmirrorfilterid
        '''
        result = self._values.get("traffic_mirror_filter_id")
        assert result is not None, "Required property 'traffic_mirror_filter_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror rule.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]]:
        '''The destination port range.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-destinationportrange
        '''
        result = self._values.get("destination_port_range")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]], result)

    @builtins.property
    def protocol(self) -> typing.Optional[jsii.Number]:
        '''The protocol, for example UDP, to assign to the Traffic Mirror rule.

        For information about the protocol value, see `Protocol Numbers <https://docs.aws.amazon.com/https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml>`_ on the Internet Assigned Numbers Authority (IANA) website.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-protocol
        '''
        result = self._values.get("protocol")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def source_port_range(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]]:
        '''The source port range.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html#cfn-ec2-trafficmirrorfilterrule-sourceportrange
        '''
        result = self._values.get("source_port_range")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTrafficMirrorFilterRuleProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTrafficMirrorSession(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorSession",
):
    '''Creates a Traffic Mirror session.

    A Traffic Mirror session actively copies packets from a Traffic Mirror source to a Traffic Mirror target. Create a filter, and then assign it to the session to define a subset of the traffic to mirror, for example all TCP traffic.

    The Traffic Mirror source and the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in a different VPC connected via VPC peering or a transit gateway.

    By default, no traffic is mirrored. Use `AWS::EC2::TrafficMirrorFilterRule <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorfilterrule.html>`_ to specify filter rules that specify the traffic to mirror.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html
    :cloudformationResource: AWS::EC2::TrafficMirrorSession
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_traffic_mirror_session = ec2.CfnTrafficMirrorSession(self, "MyCfnTrafficMirrorSession",
            network_interface_id="networkInterfaceId",
            session_number=123,
            traffic_mirror_filter_id="trafficMirrorFilterId",
            traffic_mirror_target_id="trafficMirrorTargetId",
        
            # the properties below are optional
            description="description",
            packet_length=123,
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            virtual_network_id=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_interface_id: builtins.str,
        session_number: jsii.Number,
        traffic_mirror_filter_id: builtins.str,
        traffic_mirror_target_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        packet_length: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        virtual_network_id: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param network_interface_id: The ID of the source network interface.
        :param session_number: The session number determines the order in which sessions are evaluated when an interface is used by multiple sessions. The first session with a matching filter is the one that mirrors the packets. Valid values are 1-32766.
        :param traffic_mirror_filter_id: The ID of the Traffic Mirror filter.
        :param traffic_mirror_target_id: The ID of the Traffic Mirror target.
        :param description: The description of the Traffic Mirror session.
        :param packet_length: The number of bytes in each packet to mirror. These are bytes after the VXLAN header. Do not specify this parameter when you want to mirror the entire packet. To mirror a subset of the packet, set this to the length (in bytes) that you want to mirror. For example, if you set this value to 100, then the first 100 bytes that meet the filter criteria are copied to the target. If you do not want to mirror the entire packet, use the ``PacketLength`` parameter to specify the number of bytes in each packet to mirror. For sessions with Network Load Balancer (NLB) Traffic Mirror targets the default ``PacketLength`` will be set to 8500. Valid values are 1-8500. Setting a ``PacketLength`` greater than 8500 will result in an error response.
        :param tags: The tags to assign to a Traffic Mirror session.
        :param virtual_network_id: The VXLAN ID for the Traffic Mirror session. For more information about the VXLAN protocol, see `RFC 7348 <https://docs.aws.amazon.com/https://tools.ietf.org/html/rfc7348>`_ . If you do not specify a ``VirtualNetworkId`` , an account-wide unique id is chosen at random.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e0df29e9de2cc6eed997cd0738e89aa6fc9bdffd0c700ef4584f2c9e0a82bb8)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTrafficMirrorSessionProps(
            network_interface_id=network_interface_id,
            session_number=session_number,
            traffic_mirror_filter_id=traffic_mirror_filter_id,
            traffic_mirror_target_id=traffic_mirror_target_id,
            description=description,
            packet_length=packet_length,
            tags=tags,
            virtual_network_id=virtual_network_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d7de9b275c66d169a52141d4946af458aa37cb352101d9d285be17a4f8127775)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5175b811144be72e2972ae8537d98f6781fc67b9b4b511fd17c185da6b52b510)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        '''The ID of the source network interface.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__88364a9ef675f46540f613bc4cc3f9e508a3c84e4ae23f262224ea0da8b0a550)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="sessionNumber")
    def session_number(self) -> jsii.Number:
        '''The session number determines the order in which sessions are evaluated when an interface is used by multiple sessions.'''
        return typing.cast(jsii.Number, jsii.get(self, "sessionNumber"))

    @session_number.setter
    def session_number(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29177776de9d50bf58263ace2dffe1059e0461b4367b3472815febcea6d37035)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sessionNumber", value)

    @builtins.property
    @jsii.member(jsii_name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> builtins.str:
        '''The ID of the Traffic Mirror filter.'''
        return typing.cast(builtins.str, jsii.get(self, "trafficMirrorFilterId"))

    @traffic_mirror_filter_id.setter
    def traffic_mirror_filter_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8bdb9ebefe44a551d25fac218ad2fa7a08d89dfeb20fe785cb28618d28d85f64)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trafficMirrorFilterId", value)

    @builtins.property
    @jsii.member(jsii_name="trafficMirrorTargetId")
    def traffic_mirror_target_id(self) -> builtins.str:
        '''The ID of the Traffic Mirror target.'''
        return typing.cast(builtins.str, jsii.get(self, "trafficMirrorTargetId"))

    @traffic_mirror_target_id.setter
    def traffic_mirror_target_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c749c7fc0935214e5efa1d67d38f275bc4679b3217cf7ef8c93259eb0e9f861)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trafficMirrorTargetId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror session.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4239210691e02d4eea905b9be001d8302bb77db3dde61743cea1aa5b6d2a3adb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="packetLength")
    def packet_length(self) -> typing.Optional[jsii.Number]:
        '''The number of bytes in each packet to mirror.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "packetLength"))

    @packet_length.setter
    def packet_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9aaf61851419d979865e5ff3ad332c3b90ca87f0fd776502a722e2ebe1429297)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "packetLength", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to a Traffic Mirror session.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9cef8de482d63e77fb4dc5a3633142e1ab76a00eec80854c5d9bbd7390fb5f1a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="virtualNetworkId")
    def virtual_network_id(self) -> typing.Optional[jsii.Number]:
        '''The VXLAN ID for the Traffic Mirror session.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "virtualNetworkId"))

    @virtual_network_id.setter
    def virtual_network_id(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e4afaa938b95b8222db16ad536740a420867628edc8874a81c78117a7d30a9e8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "virtualNetworkId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorSessionProps",
    jsii_struct_bases=[],
    name_mapping={
        "network_interface_id": "networkInterfaceId",
        "session_number": "sessionNumber",
        "traffic_mirror_filter_id": "trafficMirrorFilterId",
        "traffic_mirror_target_id": "trafficMirrorTargetId",
        "description": "description",
        "packet_length": "packetLength",
        "tags": "tags",
        "virtual_network_id": "virtualNetworkId",
    },
)
class CfnTrafficMirrorSessionProps:
    def __init__(
        self,
        *,
        network_interface_id: builtins.str,
        session_number: jsii.Number,
        traffic_mirror_filter_id: builtins.str,
        traffic_mirror_target_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        packet_length: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        virtual_network_id: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties for defining a ``CfnTrafficMirrorSession``.

        :param network_interface_id: The ID of the source network interface.
        :param session_number: The session number determines the order in which sessions are evaluated when an interface is used by multiple sessions. The first session with a matching filter is the one that mirrors the packets. Valid values are 1-32766.
        :param traffic_mirror_filter_id: The ID of the Traffic Mirror filter.
        :param traffic_mirror_target_id: The ID of the Traffic Mirror target.
        :param description: The description of the Traffic Mirror session.
        :param packet_length: The number of bytes in each packet to mirror. These are bytes after the VXLAN header. Do not specify this parameter when you want to mirror the entire packet. To mirror a subset of the packet, set this to the length (in bytes) that you want to mirror. For example, if you set this value to 100, then the first 100 bytes that meet the filter criteria are copied to the target. If you do not want to mirror the entire packet, use the ``PacketLength`` parameter to specify the number of bytes in each packet to mirror. For sessions with Network Load Balancer (NLB) Traffic Mirror targets the default ``PacketLength`` will be set to 8500. Valid values are 1-8500. Setting a ``PacketLength`` greater than 8500 will result in an error response.
        :param tags: The tags to assign to a Traffic Mirror session.
        :param virtual_network_id: The VXLAN ID for the Traffic Mirror session. For more information about the VXLAN protocol, see `RFC 7348 <https://docs.aws.amazon.com/https://tools.ietf.org/html/rfc7348>`_ . If you do not specify a ``VirtualNetworkId`` , an account-wide unique id is chosen at random.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_traffic_mirror_session_props = ec2.CfnTrafficMirrorSessionProps(
                network_interface_id="networkInterfaceId",
                session_number=123,
                traffic_mirror_filter_id="trafficMirrorFilterId",
                traffic_mirror_target_id="trafficMirrorTargetId",
            
                # the properties below are optional
                description="description",
                packet_length=123,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                virtual_network_id=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__410c9163482a74952290246bbd3c364855d8d943a582d683fbe831b279cc26de)
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument session_number", value=session_number, expected_type=type_hints["session_number"])
            check_type(argname="argument traffic_mirror_filter_id", value=traffic_mirror_filter_id, expected_type=type_hints["traffic_mirror_filter_id"])
            check_type(argname="argument traffic_mirror_target_id", value=traffic_mirror_target_id, expected_type=type_hints["traffic_mirror_target_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument packet_length", value=packet_length, expected_type=type_hints["packet_length"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument virtual_network_id", value=virtual_network_id, expected_type=type_hints["virtual_network_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_interface_id": network_interface_id,
            "session_number": session_number,
            "traffic_mirror_filter_id": traffic_mirror_filter_id,
            "traffic_mirror_target_id": traffic_mirror_target_id,
        }
        if description is not None:
            self._values["description"] = description
        if packet_length is not None:
            self._values["packet_length"] = packet_length
        if tags is not None:
            self._values["tags"] = tags
        if virtual_network_id is not None:
            self._values["virtual_network_id"] = virtual_network_id

    @builtins.property
    def network_interface_id(self) -> builtins.str:
        '''The ID of the source network interface.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        assert result is not None, "Required property 'network_interface_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def session_number(self) -> jsii.Number:
        '''The session number determines the order in which sessions are evaluated when an interface is used by multiple sessions.

        The first session with a matching filter is the one that mirrors the packets.

        Valid values are 1-32766.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-sessionnumber
        '''
        result = self._values.get("session_number")
        assert result is not None, "Required property 'session_number' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def traffic_mirror_filter_id(self) -> builtins.str:
        '''The ID of the Traffic Mirror filter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-trafficmirrorfilterid
        '''
        result = self._values.get("traffic_mirror_filter_id")
        assert result is not None, "Required property 'traffic_mirror_filter_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def traffic_mirror_target_id(self) -> builtins.str:
        '''The ID of the Traffic Mirror target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-trafficmirrortargetid
        '''
        result = self._values.get("traffic_mirror_target_id")
        assert result is not None, "Required property 'traffic_mirror_target_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror session.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def packet_length(self) -> typing.Optional[jsii.Number]:
        '''The number of bytes in each packet to mirror.

        These are bytes after the VXLAN header. Do not specify this parameter when you want to mirror the entire packet. To mirror a subset of the packet, set this to the length (in bytes) that you want to mirror. For example, if you set this value to 100, then the first 100 bytes that meet the filter criteria are copied to the target.

        If you do not want to mirror the entire packet, use the ``PacketLength`` parameter to specify the number of bytes in each packet to mirror.

        For sessions with Network Load Balancer (NLB) Traffic Mirror targets the default ``PacketLength`` will be set to 8500. Valid values are 1-8500. Setting a ``PacketLength`` greater than 8500 will result in an error response.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-packetlength
        '''
        result = self._values.get("packet_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to a Traffic Mirror session.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def virtual_network_id(self) -> typing.Optional[jsii.Number]:
        '''The VXLAN ID for the Traffic Mirror session.

        For more information about the VXLAN protocol, see `RFC 7348 <https://docs.aws.amazon.com/https://tools.ietf.org/html/rfc7348>`_ . If you do not specify a ``VirtualNetworkId`` , an account-wide unique id is chosen at random.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html#cfn-ec2-trafficmirrorsession-virtualnetworkid
        '''
        result = self._values.get("virtual_network_id")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTrafficMirrorSessionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTrafficMirrorTarget(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorTarget",
):
    '''Specifies a target for your Traffic Mirror session.

    A Traffic Mirror target is the destination for mirrored traffic. The Traffic Mirror source and the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in different VPCs connected via VPC peering or a transit gateway.

    A Traffic Mirror target can be a network interface, a Network Load Balancer, or a Gateway Load Balancer endpoint.

    To use the target in a Traffic Mirror session, use `AWS::EC2::TrafficMirrorSession <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrorsession.html>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html
    :cloudformationResource: AWS::EC2::TrafficMirrorTarget
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_traffic_mirror_target = ec2.CfnTrafficMirrorTarget(self, "MyCfnTrafficMirrorTarget",
            description="description",
            gateway_load_balancer_endpoint_id="gatewayLoadBalancerEndpointId",
            network_interface_id="networkInterfaceId",
            network_load_balancer_arn="networkLoadBalancerArn",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        gateway_load_balancer_endpoint_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        network_load_balancer_arn: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param description: The description of the Traffic Mirror target.
        :param gateway_load_balancer_endpoint_id: The ID of the Gateway Load Balancer endpoint.
        :param network_interface_id: The network interface ID that is associated with the target.
        :param network_load_balancer_arn: The Amazon Resource Name (ARN) of the Network Load Balancer that is associated with the target.
        :param tags: The tags to assign to the Traffic Mirror target.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__70ed5196cebe14b98a0bfa7a8c8b551d0ff3f3ea5d39ad701b844d631ee5f5f9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTrafficMirrorTargetProps(
            description=description,
            gateway_load_balancer_endpoint_id=gateway_load_balancer_endpoint_id,
            network_interface_id=network_interface_id,
            network_load_balancer_arn=network_load_balancer_arn,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49dd29a3ac59afe75d377125f6f9e1efacc539e3e7011335b7aefd19558be691)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__821abe97977d9065ae17ba3689f3ebcfb2870f85843446072880333869b48c3a)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror target.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bbfcefac30f45571dc267f516f68fed7eb6e0db8a5c14e752682147282c313ab)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="gatewayLoadBalancerEndpointId")
    def gateway_load_balancer_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the Gateway Load Balancer endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "gatewayLoadBalancerEndpointId"))

    @gateway_load_balancer_endpoint_id.setter
    def gateway_load_balancer_endpoint_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__104a6fbde32b1c4fb2e881070de0dd6d5a689f6fa4b0759a1977dbba27ddf990)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "gatewayLoadBalancerEndpointId", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The network interface ID that is associated with the target.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5dd0de64890549ffacaee1e73ac06cea8ed5873474d59f91aa3c31d79b2de33a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="networkLoadBalancerArn")
    def network_load_balancer_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Network Load Balancer that is associated with the target.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "networkLoadBalancerArn"))

    @network_load_balancer_arn.setter
    def network_load_balancer_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__534c2f4f36ca1428397aa3d1d19afe134f4ef3241c04fd666698c4fafebefc59)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkLoadBalancerArn", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to the Traffic Mirror target.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__87ac4a1681abc492ae8bee1fd3764a93017519a9b19f62fc4ad2099d9ba48c93)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTrafficMirrorTargetProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "gateway_load_balancer_endpoint_id": "gatewayLoadBalancerEndpointId",
        "network_interface_id": "networkInterfaceId",
        "network_load_balancer_arn": "networkLoadBalancerArn",
        "tags": "tags",
    },
)
class CfnTrafficMirrorTargetProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        gateway_load_balancer_endpoint_id: typing.Optional[builtins.str] = None,
        network_interface_id: typing.Optional[builtins.str] = None,
        network_load_balancer_arn: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTrafficMirrorTarget``.

        :param description: The description of the Traffic Mirror target.
        :param gateway_load_balancer_endpoint_id: The ID of the Gateway Load Balancer endpoint.
        :param network_interface_id: The network interface ID that is associated with the target.
        :param network_load_balancer_arn: The Amazon Resource Name (ARN) of the Network Load Balancer that is associated with the target.
        :param tags: The tags to assign to the Traffic Mirror target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_traffic_mirror_target_props = ec2.CfnTrafficMirrorTargetProps(
                description="description",
                gateway_load_balancer_endpoint_id="gatewayLoadBalancerEndpointId",
                network_interface_id="networkInterfaceId",
                network_load_balancer_arn="networkLoadBalancerArn",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83eb5785ef7f80ecff2d793495ef05125c400dcec136b602834d403b53f91776)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument gateway_load_balancer_endpoint_id", value=gateway_load_balancer_endpoint_id, expected_type=type_hints["gateway_load_balancer_endpoint_id"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument network_load_balancer_arn", value=network_load_balancer_arn, expected_type=type_hints["network_load_balancer_arn"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if gateway_load_balancer_endpoint_id is not None:
            self._values["gateway_load_balancer_endpoint_id"] = gateway_load_balancer_endpoint_id
        if network_interface_id is not None:
            self._values["network_interface_id"] = network_interface_id
        if network_load_balancer_arn is not None:
            self._values["network_load_balancer_arn"] = network_load_balancer_arn
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the Traffic Mirror target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html#cfn-ec2-trafficmirrortarget-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def gateway_load_balancer_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the Gateway Load Balancer endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html#cfn-ec2-trafficmirrortarget-gatewayloadbalancerendpointid
        '''
        result = self._values.get("gateway_load_balancer_endpoint_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_interface_id(self) -> typing.Optional[builtins.str]:
        '''The network interface ID that is associated with the target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html#cfn-ec2-trafficmirrortarget-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_load_balancer_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Network Load Balancer that is associated with the target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html#cfn-ec2-trafficmirrortarget-networkloadbalancerarn
        '''
        result = self._values.get("network_load_balancer_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to assign to the Traffic Mirror target.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-trafficmirrortarget.html#cfn-ec2-trafficmirrortarget-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTrafficMirrorTargetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGateway",
):
    '''Specifies a transit gateway.

    You can use a transit gateway to interconnect your virtual private clouds (VPC) and on-premises networks. After the transit gateway enters the ``available`` state, you can attach your VPCs and VPN connections to the transit gateway.

    To attach your VPCs, use `AWS::EC2::TransitGatewayAttachment <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html>`_ .

    To attach a VPN connection, use `AWS::EC2::CustomerGateway <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customer-gateway.html>`_ to create a customer gateway and specify the ID of the customer gateway and the ID of the transit gateway in a call to `AWS::EC2::VPNConnection <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-connection.html>`_ .

    When you create a transit gateway, we create a default transit gateway route table and use it as the default association route table and the default propagation route table. You can use `AWS::EC2::TransitGatewayRouteTable <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetable.html>`_ to create additional transit gateway route tables. If you disable automatic route propagation, we do not create a default transit gateway route table. You can use `AWS::EC2::TransitGatewayRouteTablePropagation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetablepropagation.html>`_ to propagate routes from a resource attachment to a transit gateway route table. If you disable automatic associations, you can use `AWS::EC2::TransitGatewayRouteTableAssociation <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetableassociation.html>`_ to associate a resource attachment with a transit gateway route table.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html
    :cloudformationResource: AWS::EC2::TransitGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway = ec2.CfnTransitGateway(self, "MyCfnTransitGateway",
            amazon_side_asn=123,
            association_default_route_table_id="associationDefaultRouteTableId",
            auto_accept_shared_attachments="autoAcceptSharedAttachments",
            default_route_table_association="defaultRouteTableAssociation",
            default_route_table_propagation="defaultRouteTablePropagation",
            description="description",
            dns_support="dnsSupport",
            multicast_support="multicastSupport",
            propagation_default_route_table_id="propagationDefaultRouteTableId",
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            transit_gateway_cidr_blocks=["transitGatewayCidrBlocks"],
            vpn_ecmp_support="vpnEcmpSupport"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
        association_default_route_table_id: typing.Optional[builtins.str] = None,
        auto_accept_shared_attachments: typing.Optional[builtins.str] = None,
        default_route_table_association: typing.Optional[builtins.str] = None,
        default_route_table_propagation: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_support: typing.Optional[builtins.str] = None,
        multicast_support: typing.Optional[builtins.str] = None,
        propagation_default_route_table_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transit_gateway_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        vpn_ecmp_support: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param amazon_side_asn: A private Autonomous System Number (ASN) for the Amazon side of a BGP session. The range is 64512 to 65534 for 16-bit ASNs. The default is 64512.
        :param association_default_route_table_id: The ID of the default association route table.
        :param auto_accept_shared_attachments: Enable or disable automatic acceptance of attachment requests. Disabled by default.
        :param default_route_table_association: Enable or disable automatic association with the default association route table. Enabled by default.
        :param default_route_table_propagation: Enable or disable automatic propagation of routes to the default propagation route table. Enabled by default.
        :param description: The description of the transit gateway.
        :param dns_support: Enable or disable DNS support. Enabled by default.
        :param multicast_support: Indicates whether multicast is enabled on the transit gateway.
        :param propagation_default_route_table_id: The ID of the default propagation route table.
        :param tags: The tags for the transit gateway.
        :param transit_gateway_cidr_blocks: The transit gateway CIDR blocks.
        :param vpn_ecmp_support: Enable or disable Equal Cost Multipath Protocol support. Enabled by default.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bba1945c40ffe23ea319a1157d643d40dd9ada3eb2884ee096699e54979ccfc7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayProps(
            amazon_side_asn=amazon_side_asn,
            association_default_route_table_id=association_default_route_table_id,
            auto_accept_shared_attachments=auto_accept_shared_attachments,
            default_route_table_association=default_route_table_association,
            default_route_table_propagation=default_route_table_propagation,
            description=description,
            dns_support=dns_support,
            multicast_support=multicast_support,
            propagation_default_route_table_id=propagation_default_route_table_id,
            tags=tags,
            transit_gateway_cidr_blocks=transit_gateway_cidr_blocks,
            vpn_ecmp_support=vpn_ecmp_support,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f706d2be5763b7ea9cc3a860496bdbe2a371e281d746e0368dab2a6e4cb9537)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72ff58700f4827ac68ac9f42abe54b7fc28d95c1a7d59fa84f04db26f93256cb)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayArn")
    def attr_transit_gateway_arn(self) -> builtins.str:
        '''
        :cloudformationAttribute: TransitGatewayArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayArn"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="amazonSideAsn")
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''A private Autonomous System Number (ASN) for the Amazon side of a BGP session.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "amazonSideAsn"))

    @amazon_side_asn.setter
    def amazon_side_asn(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b46c1015641c6edb0bc297526a4064793b9e88605b3212dd0441b546292678c5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "amazonSideAsn", value)

    @builtins.property
    @jsii.member(jsii_name="associationDefaultRouteTableId")
    def association_default_route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the default association route table.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "associationDefaultRouteTableId"))

    @association_default_route_table_id.setter
    def association_default_route_table_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__932b4e28bca7c84b0f853908182e3c0a62a82ce26b539df207c870e6764698a8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "associationDefaultRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="autoAcceptSharedAttachments")
    def auto_accept_shared_attachments(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic acceptance of attachment requests.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "autoAcceptSharedAttachments"))

    @auto_accept_shared_attachments.setter
    def auto_accept_shared_attachments(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7aa5bee9d95a5d078006432292f402d76b063679b39dc0326a45947bf157355f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "autoAcceptSharedAttachments", value)

    @builtins.property
    @jsii.member(jsii_name="defaultRouteTableAssociation")
    def default_route_table_association(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic association with the default association route table.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "defaultRouteTableAssociation"))

    @default_route_table_association.setter
    def default_route_table_association(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c1e89cc250279218430f64dcd73ca74122a1a5ab134a94e33b088fe88482cf6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "defaultRouteTableAssociation", value)

    @builtins.property
    @jsii.member(jsii_name="defaultRouteTablePropagation")
    def default_route_table_propagation(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic propagation of routes to the default propagation route table.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "defaultRouteTablePropagation"))

    @default_route_table_propagation.setter
    def default_route_table_propagation(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__126744879944d00f0dc7a54fee23cb014756b685c183a2d78932627db1e3deec)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "defaultRouteTablePropagation", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the transit gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c73a285a2d555dd54da4dbf2184b1382397e84bb9103e210bbe3f558a877be3f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="dnsSupport")
    def dns_support(self) -> typing.Optional[builtins.str]:
        '''Enable or disable DNS support.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "dnsSupport"))

    @dns_support.setter
    def dns_support(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d5f3d15ac6d140a64177826bd00ab6cfa60d0860fbf0018422b793d774fa5ace)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dnsSupport", value)

    @builtins.property
    @jsii.member(jsii_name="multicastSupport")
    def multicast_support(self) -> typing.Optional[builtins.str]:
        '''Indicates whether multicast is enabled on the transit gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "multicastSupport"))

    @multicast_support.setter
    def multicast_support(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b6fd0b36d4c60bd1f6136b3f8cff6b7319a43959272b1a770525b5507e6013bd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "multicastSupport", value)

    @builtins.property
    @jsii.member(jsii_name="propagationDefaultRouteTableId")
    def propagation_default_route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the default propagation route table.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "propagationDefaultRouteTableId"))

    @propagation_default_route_table_id.setter
    def propagation_default_route_table_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96eb40466e83d16bb71ed5f295e56c3ec41178edaf7dada2d08c5cfbf11b20fc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "propagationDefaultRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ce7a4c126005c51509a0bd7f2c9b3dd762ba3bd0c8c5a303dfdcdb1ae2aa45ac)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayCidrBlocks")
    def transit_gateway_cidr_blocks(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The transit gateway CIDR blocks.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "transitGatewayCidrBlocks"))

    @transit_gateway_cidr_blocks.setter
    def transit_gateway_cidr_blocks(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3c559ff74e846d70e5cc985077f2c0d0476db043c3f6210c18ed96783d61ebf)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayCidrBlocks", value)

    @builtins.property
    @jsii.member(jsii_name="vpnEcmpSupport")
    def vpn_ecmp_support(self) -> typing.Optional[builtins.str]:
        '''Enable or disable Equal Cost Multipath Protocol support.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpnEcmpSupport"))

    @vpn_ecmp_support.setter
    def vpn_ecmp_support(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1baa174f73ad52695d79d82af5563d4a38cc3f7ba388cd069fb17240a549ed38)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnEcmpSupport", value)


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayAttachment",
):
    '''Attaches a VPC to a transit gateway.

    If you attach a VPC with a CIDR range that overlaps the CIDR range of a VPC that is already attached, the new VPC CIDR range is not propagated to the default propagation route table.

    To send VPC traffic to an attached transit gateway, add a route to the VPC route table using `AWS::EC2::Route <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html>`_ .

    To update tags for a VPC attachment after creation without replacing the attachment, use `AWS::EC2::TransitGatewayVpcAttachment <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html>`_ instead.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html
    :cloudformationResource: AWS::EC2::TransitGatewayAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # options: Any
        
        cfn_transit_gateway_attachment = ec2.CfnTransitGatewayAttachment(self, "MyCfnTransitGatewayAttachment",
            subnet_ids=["subnetIds"],
            transit_gateway_id="transitGatewayId",
            vpc_id="vpcId",
        
            # the properties below are optional
            options=options,
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_ids: typing.Sequence[builtins.str],
        transit_gateway_id: builtins.str,
        vpc_id: builtins.str,
        options: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_ids: The IDs of one or more subnets. You can specify only one subnet per Availability Zone. You must specify at least one subnet, but we recommend that you specify two subnets for better availability. The transit gateway uses one IP address from each specified subnet.
        :param transit_gateway_id: The ID of the transit gateway.
        :param vpc_id: The ID of the VPC.
        :param options: The VPC attachment options.
        :param tags: The tags for the attachment.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eab8e96bb64a927b52383e2a842bfca63a3ece05b571bd631f2c4d980838f426)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayAttachmentProps(
            subnet_ids=subnet_ids,
            transit_gateway_id=transit_gateway_id,
            vpc_id=vpc_id,
            options=options,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cca20a7b6f10e5816fe3b6b1b7c269fa3848b7398e1ad9328f33b3141cddc8a0)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba3a3854813c8821446ab56c6c0c0162a019d23262e8cabaae93972eca57cd4c)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the attachment.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="subnetIds")
    def subnet_ids(self) -> typing.List[builtins.str]:
        '''The IDs of one or more subnets.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "subnetIds"))

    @subnet_ids.setter
    def subnet_ids(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2cc237d43b6ab6e6acbbc422259968ffb5964e270b148314d969fb42c425b873)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetIds", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__43e06e177eaf3151f23dd642b85bb7c527e74603319029db9a9f806f64dc4a70)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__721fe039d87e2e2ec45edb1476e9f8525a159282ccb9acb06a793192bb2cd6ff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="options")
    def options(self) -> typing.Any:
        '''The VPC attachment options.'''
        return typing.cast(typing.Any, jsii.get(self, "options"))

    @options.setter
    def options(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3ab60b7cc3369c5561ca038826e38262fc6d63a986ff59a5e3fe69932ff2a4d0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "options", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the attachment.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__826b56d4563bcfd9f8c247a5fcc905fa7139b5b0f5f16b21b6bdd9ee74befbc7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayAttachment.OptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "appliance_mode_support": "applianceModeSupport",
            "dns_support": "dnsSupport",
            "ipv6_support": "ipv6Support",
            "security_group_referencing_support": "securityGroupReferencingSupport",
        },
    )
    class OptionsProperty:
        def __init__(
            self,
            *,
            appliance_mode_support: typing.Optional[builtins.str] = None,
            dns_support: typing.Optional[builtins.str] = None,
            ipv6_support: typing.Optional[builtins.str] = None,
            security_group_referencing_support: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the VPC attachment options.

            :param appliance_mode_support: Enable or disable appliance mode support. The default is ``disable`` .
            :param dns_support: Enable or disable DNS support. The default is ``disable`` .
            :param ipv6_support: Enable or disable IPv6 support. The default is ``disable`` .
            :param security_group_referencing_support: Enables you to reference a security group across VPCs attached to a transit gateway (TGW). Use this option to simplify security group management and control of instance-to-instance traffic across VPCs that are connected by transit gateway. You can also use this option to migrate from VPC peering (which was the only option that supported security group referencing) to transit gateways (which now also support security group referencing). This option is disabled by default and there are no additional costs to use this feature. For important information about this feature, see `Create a transit gateway <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#create-tgw>`_ in the *AWS Transit Gateway Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayattachment-options.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                options_property = ec2.CfnTransitGatewayAttachment.OptionsProperty(
                    appliance_mode_support="applianceModeSupport",
                    dns_support="dnsSupport",
                    ipv6_support="ipv6Support",
                    security_group_referencing_support="securityGroupReferencingSupport"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__1a6a91070bc957616b318464b989714fb81382073cacd0ab2b00be277236a29a)
                check_type(argname="argument appliance_mode_support", value=appliance_mode_support, expected_type=type_hints["appliance_mode_support"])
                check_type(argname="argument dns_support", value=dns_support, expected_type=type_hints["dns_support"])
                check_type(argname="argument ipv6_support", value=ipv6_support, expected_type=type_hints["ipv6_support"])
                check_type(argname="argument security_group_referencing_support", value=security_group_referencing_support, expected_type=type_hints["security_group_referencing_support"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if appliance_mode_support is not None:
                self._values["appliance_mode_support"] = appliance_mode_support
            if dns_support is not None:
                self._values["dns_support"] = dns_support
            if ipv6_support is not None:
                self._values["ipv6_support"] = ipv6_support
            if security_group_referencing_support is not None:
                self._values["security_group_referencing_support"] = security_group_referencing_support

        @builtins.property
        def appliance_mode_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable appliance mode support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayattachment-options.html#cfn-ec2-transitgatewayattachment-options-appliancemodesupport
            '''
            result = self._values.get("appliance_mode_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def dns_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable DNS support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayattachment-options.html#cfn-ec2-transitgatewayattachment-options-dnssupport
            '''
            result = self._values.get("dns_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ipv6_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable IPv6 support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayattachment-options.html#cfn-ec2-transitgatewayattachment-options-ipv6support
            '''
            result = self._values.get("ipv6_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def security_group_referencing_support(self) -> typing.Optional[builtins.str]:
            '''Enables you to reference a security group across VPCs attached to a transit gateway (TGW).

            Use this option to simplify security group management and control of instance-to-instance traffic across VPCs that are connected by transit gateway. You can also use this option to migrate from VPC peering (which was the only option that supported security group referencing) to transit gateways (which now also support security group referencing). This option is disabled by default and there are no additional costs to use this feature.

            For important information about this feature, see `Create a transit gateway <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html#create-tgw>`_ in the *AWS Transit Gateway Guide* .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayattachment-options.html#cfn-ec2-transitgatewayattachment-options-securitygroupreferencingsupport
            '''
            result = self._values.get("security_group_referencing_support")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "OptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_ids": "subnetIds",
        "transit_gateway_id": "transitGatewayId",
        "vpc_id": "vpcId",
        "options": "options",
        "tags": "tags",
    },
)
class CfnTransitGatewayAttachmentProps:
    def __init__(
        self,
        *,
        subnet_ids: typing.Sequence[builtins.str],
        transit_gateway_id: builtins.str,
        vpc_id: builtins.str,
        options: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayAttachment``.

        :param subnet_ids: The IDs of one or more subnets. You can specify only one subnet per Availability Zone. You must specify at least one subnet, but we recommend that you specify two subnets for better availability. The transit gateway uses one IP address from each specified subnet.
        :param transit_gateway_id: The ID of the transit gateway.
        :param vpc_id: The ID of the VPC.
        :param options: The VPC attachment options.
        :param tags: The tags for the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # options: Any
            
            cfn_transit_gateway_attachment_props = ec2.CfnTransitGatewayAttachmentProps(
                subnet_ids=["subnetIds"],
                transit_gateway_id="transitGatewayId",
                vpc_id="vpcId",
            
                # the properties below are optional
                options=options,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07286507bb35af9dd738df090e52540130e6551e84dffc04995d5dea86a6b97c)
            check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument options", value=options, expected_type=type_hints["options"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_ids": subnet_ids,
            "transit_gateway_id": transit_gateway_id,
            "vpc_id": vpc_id,
        }
        if options is not None:
            self._values["options"] = options
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def subnet_ids(self) -> typing.List[builtins.str]:
        '''The IDs of one or more subnets.

        You can specify only one subnet per Availability Zone. You must specify at least one subnet, but we recommend that you specify two subnets for better availability. The transit gateway uses one IP address from each specified subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html#cfn-ec2-transitgatewayattachment-subnetids
        '''
        result = self._values.get("subnet_ids")
        assert result is not None, "Required property 'subnet_ids' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html#cfn-ec2-transitgatewayattachment-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        assert result is not None, "Required property 'transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html#cfn-ec2-transitgatewayattachment-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def options(self) -> typing.Any:
        '''The VPC attachment options.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html#cfn-ec2-transitgatewayattachment-options
        '''
        result = self._values.get("options")
        return typing.cast(typing.Any, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayattachment.html#cfn-ec2-transitgatewayattachment-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayConnect(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayConnect",
):
    '''Creates a Connect attachment from a specified transit gateway attachment.

    A Connect attachment is a GRE-based tunnel attachment that you can use to establish a connection between a transit gateway and an appliance.

    A Connect attachment uses an existing VPC or AWS Direct Connect attachment as the underlying transport mechanism.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayconnect.html
    :cloudformationResource: AWS::EC2::TransitGatewayConnect
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_connect = ec2.CfnTransitGatewayConnect(self, "MyCfnTransitGatewayConnect",
            options=ec2.CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty(
                protocol="protocol"
            ),
            transport_transit_gateway_attachment_id="transportTransitGatewayAttachmentId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        options: typing.Union[_IResolvable_da3f097b, typing.Union["CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty", typing.Dict[builtins.str, typing.Any]]],
        transport_transit_gateway_attachment_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param options: The Connect attachment options. - protocol (gre)
        :param transport_transit_gateway_attachment_id: The ID of the attachment from which the Connect attachment was created.
        :param tags: The tags for the attachment.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1eeb889478aec2b3809f8d0f9aa281f4c3364eeacd9a24d491a895919f93be0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayConnectProps(
            options=options,
            transport_transit_gateway_attachment_id=transport_transit_gateway_attachment_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e834e78fae3188c121864fe170c35cce5c93a961423fdfaf6c4984a3ff1f3d5d)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3470664364cbc2bea67fd850b91f5bf0e8554b7f696d69ca538b2781a52d0e39)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The creation time.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the attachment.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayAttachmentId")
    def attr_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway attachment.

        :cloudformationAttribute: TransitGatewayAttachmentId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayAttachmentId"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayId")
    def attr_transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :cloudformationAttribute: TransitGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="options")
    def options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, "CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty"]:
        '''The Connect attachment options.'''
        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty"], jsii.get(self, "options"))

    @options.setter
    def options(
        self,
        value: typing.Union[_IResolvable_da3f097b, "CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f94900717c95bb6994e0b373a679236b76d90c6840a7c302377032733318cef)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "options", value)

    @builtins.property
    @jsii.member(jsii_name="transportTransitGatewayAttachmentId")
    def transport_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment from which the Connect attachment was created.'''
        return typing.cast(builtins.str, jsii.get(self, "transportTransitGatewayAttachmentId"))

    @transport_transit_gateway_attachment_id.setter
    def transport_transit_gateway_attachment_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76ac46a299fc52743f1e23fb957186961b3558b17e48998d3bbaa8039e98383d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transportTransitGatewayAttachmentId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the attachment.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b237c6b2758193e6b7a3c82ba11a22ea4f505054d8f95b271d5b3aac76ccdfc0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={"protocol": "protocol"},
    )
    class TransitGatewayConnectOptionsProperty:
        def __init__(self, *, protocol: typing.Optional[builtins.str] = None) -> None:
            '''Describes the Connect attachment options.

            :param protocol: The tunnel protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayconnect-transitgatewayconnectoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                transit_gateway_connect_options_property = ec2.CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty(
                    protocol="protocol"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__f28cf9493a9ba4af846e6c741893e0f0824bc477c2f1963741643adc413766d3)
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if protocol is not None:
                self._values["protocol"] = protocol

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The tunnel protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayconnect-transitgatewayconnectoptions.html#cfn-ec2-transitgatewayconnect-transitgatewayconnectoptions-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "TransitGatewayConnectOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayConnectProps",
    jsii_struct_bases=[],
    name_mapping={
        "options": "options",
        "transport_transit_gateway_attachment_id": "transportTransitGatewayAttachmentId",
        "tags": "tags",
    },
)
class CfnTransitGatewayConnectProps:
    def __init__(
        self,
        *,
        options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
        transport_transit_gateway_attachment_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayConnect``.

        :param options: The Connect attachment options. - protocol (gre)
        :param transport_transit_gateway_attachment_id: The ID of the attachment from which the Connect attachment was created.
        :param tags: The tags for the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayconnect.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_connect_props = ec2.CfnTransitGatewayConnectProps(
                options=ec2.CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty(
                    protocol="protocol"
                ),
                transport_transit_gateway_attachment_id="transportTransitGatewayAttachmentId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae4b1efff7cf5a4fab7c16d5ffad18f9c18dbd0d23dd3fa072685e3264ade5e1)
            check_type(argname="argument options", value=options, expected_type=type_hints["options"])
            check_type(argname="argument transport_transit_gateway_attachment_id", value=transport_transit_gateway_attachment_id, expected_type=type_hints["transport_transit_gateway_attachment_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "options": options,
            "transport_transit_gateway_attachment_id": transport_transit_gateway_attachment_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def options(
        self,
    ) -> typing.Union[_IResolvable_da3f097b, CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty]:
        '''The Connect attachment options.

        - protocol (gre)

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayconnect.html#cfn-ec2-transitgatewayconnect-options
        '''
        result = self._values.get("options")
        assert result is not None, "Required property 'options' is missing"
        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty], result)

    @builtins.property
    def transport_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment from which the Connect attachment was created.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayconnect.html#cfn-ec2-transitgatewayconnect-transporttransitgatewayattachmentid
        '''
        result = self._values.get("transport_transit_gateway_attachment_id")
        assert result is not None, "Required property 'transport_transit_gateway_attachment_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayconnect.html#cfn-ec2-transitgatewayconnect-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayConnectProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayMulticastDomain(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastDomain",
):
    '''Creates a multicast domain using the specified transit gateway.

    The transit gateway must be in the available state before you create a domain.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomain.html
    :cloudformationResource: AWS::EC2::TransitGatewayMulticastDomain
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # options: Any
        
        cfn_transit_gateway_multicast_domain = ec2.CfnTransitGatewayMulticastDomain(self, "MyCfnTransitGatewayMulticastDomain",
            transit_gateway_id="transitGatewayId",
        
            # the properties below are optional
            options=options,
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        transit_gateway_id: builtins.str,
        options: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param transit_gateway_id: The ID of the transit gateway.
        :param options: The options for the transit gateway multicast domain. - AutoAcceptSharedAssociations (enable | disable) - Igmpv2Support (enable | disable) - StaticSourcesSupport (enable | disable)
        :param tags: The tags for the transit gateway multicast domain.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12d9bae5c632fc5f2e4010c8fc9c73ce070047631f45ed391c85bafbebf8fab3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayMulticastDomainProps(
            transit_gateway_id=transit_gateway_id, options=options, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5866dec7826d5bb1b5fb131f6f8fdc1860951c1171fac450128c46dfb15c9239)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f8c6938f04ffa9c4a27f0f78a14dc7d72c656d8fd8e1c29e4cc654e39bfa838)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The time the multicast domain was created.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the multicast domain.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayMulticastDomainArn")
    def attr_transit_gateway_multicast_domain_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the multicast domain.

        :cloudformationAttribute: TransitGatewayMulticastDomainArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayMulticastDomainArn"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayMulticastDomainId")
    def attr_transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the multicast domain.

        :cloudformationAttribute: TransitGatewayMulticastDomainId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayMulticastDomainId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__56ba4d60bd49e9d2b00ad7a61667dde0b5864131d85ff7aec7779d924936457d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="options")
    def options(self) -> typing.Any:
        '''The options for the transit gateway multicast domain.'''
        return typing.cast(typing.Any, jsii.get(self, "options"))

    @options.setter
    def options(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc15811b4637c83850a22de14f995dae019e06cceeb500bda4760e1f88ccd349)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "options", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway multicast domain.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__370c22228824f814c2fb5c861751b56345c371829d3c1aca9ba5d3efdfc4787d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastDomain.OptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "auto_accept_shared_associations": "autoAcceptSharedAssociations",
            "igmpv2_support": "igmpv2Support",
            "static_sources_support": "staticSourcesSupport",
        },
    )
    class OptionsProperty:
        def __init__(
            self,
            *,
            auto_accept_shared_associations: typing.Optional[builtins.str] = None,
            igmpv2_support: typing.Optional[builtins.str] = None,
            static_sources_support: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The options for the transit gateway multicast domain.

            :param auto_accept_shared_associations: Indicates whether to automatically accept cross-account subnet associations that are associated with the transit gateway multicast domain.
            :param igmpv2_support: Specify whether to enable Internet Group Management Protocol (IGMP) version 2 for the transit gateway multicast domain.
            :param static_sources_support: Specify whether to enable support for statically configuring multicast group sources for a domain.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaymulticastdomain-options.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                options_property = ec2.CfnTransitGatewayMulticastDomain.OptionsProperty(
                    auto_accept_shared_associations="autoAcceptSharedAssociations",
                    igmpv2_support="igmpv2Support",
                    static_sources_support="staticSourcesSupport"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__dc1dbcfd21d6f8129cf25adbd6eed61be19656a68a6ef09c7e5a8772bf5b032c)
                check_type(argname="argument auto_accept_shared_associations", value=auto_accept_shared_associations, expected_type=type_hints["auto_accept_shared_associations"])
                check_type(argname="argument igmpv2_support", value=igmpv2_support, expected_type=type_hints["igmpv2_support"])
                check_type(argname="argument static_sources_support", value=static_sources_support, expected_type=type_hints["static_sources_support"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if auto_accept_shared_associations is not None:
                self._values["auto_accept_shared_associations"] = auto_accept_shared_associations
            if igmpv2_support is not None:
                self._values["igmpv2_support"] = igmpv2_support
            if static_sources_support is not None:
                self._values["static_sources_support"] = static_sources_support

        @builtins.property
        def auto_accept_shared_associations(self) -> typing.Optional[builtins.str]:
            '''Indicates whether to automatically accept cross-account subnet associations that are associated with the transit gateway multicast domain.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaymulticastdomain-options.html#cfn-ec2-transitgatewaymulticastdomain-options-autoacceptsharedassociations
            '''
            result = self._values.get("auto_accept_shared_associations")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def igmpv2_support(self) -> typing.Optional[builtins.str]:
            '''Specify whether to enable Internet Group Management Protocol (IGMP) version 2 for the transit gateway multicast domain.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaymulticastdomain-options.html#cfn-ec2-transitgatewaymulticastdomain-options-igmpv2support
            '''
            result = self._values.get("igmpv2_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def static_sources_support(self) -> typing.Optional[builtins.str]:
            '''Specify whether to enable support for statically configuring multicast group sources for a domain.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaymulticastdomain-options.html#cfn-ec2-transitgatewaymulticastdomain-options-staticsourcessupport
            '''
            result = self._values.get("static_sources_support")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "OptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayMulticastDomainAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastDomainAssociation",
):
    '''Associates the specified subnets and transit gateway attachments with the specified transit gateway multicast domain.

    The transit gateway attachment must be in the available state before you can add a resource.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomainassociation.html
    :cloudformationResource: AWS::EC2::TransitGatewayMulticastDomainAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_multicast_domain_association = ec2.CfnTransitGatewayMulticastDomainAssociation(self, "MyCfnTransitGatewayMulticastDomainAssociation",
            subnet_id="subnetId",
            transit_gateway_attachment_id="transitGatewayAttachmentId",
            transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_id: The IDs of the subnets to associate with the transit gateway multicast domain.
        :param transit_gateway_attachment_id: The ID of the transit gateway attachment.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aba86311abc72a866446901528f0c54660c3faea73c8df278db0a6b6d3a3b2b9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayMulticastDomainAssociationProps(
            subnet_id=subnet_id,
            transit_gateway_attachment_id=transit_gateway_attachment_id,
            transit_gateway_multicast_domain_id=transit_gateway_multicast_domain_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62f6377db8127d6632b039d487c4b37996f466cdb9c086529970b35e61c58ba7)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4237d038461e8761bbfc04b590f1b62ab4e7c3738ef4f1de609b9a0663561870)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceId")
    def attr_resource_id(self) -> builtins.str:
        '''The ID of the resource.

        :cloudformationAttribute: ResourceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceId"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceType")
    def attr_resource_type(self) -> builtins.str:
        '''The type of resource, for example a VPC attachment.

        :cloudformationAttribute: ResourceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceType"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the resource.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The IDs of the subnets to associate with the transit gateway multicast domain.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @subnet_id.setter
    def subnet_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f62547cbe33042979a90f1bccb2f6fde3c8dd8542ff6366ad8affc3fdd4c0394)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway attachment.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayAttachmentId"))

    @transit_gateway_attachment_id.setter
    def transit_gateway_attachment_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__868fee90caf8adf36048078bdf631831c3a1c5e29bb4627fee76012226800583)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayAttachmentId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayMulticastDomainId")
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayMulticastDomainId"))

    @transit_gateway_multicast_domain_id.setter
    def transit_gateway_multicast_domain_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2680948d048e1f72a4e73ba487b2614bb6eb02bdd5e5edd3614df2ff05caeaa5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayMulticastDomainId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastDomainAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "transit_gateway_attachment_id": "transitGatewayAttachmentId",
        "transit_gateway_multicast_domain_id": "transitGatewayMulticastDomainId",
    },
)
class CfnTransitGatewayMulticastDomainAssociationProps:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayMulticastDomainAssociation``.

        :param subnet_id: The IDs of the subnets to associate with the transit gateway multicast domain.
        :param transit_gateway_attachment_id: The ID of the transit gateway attachment.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomainassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_multicast_domain_association_props = ec2.CfnTransitGatewayMulticastDomainAssociationProps(
                subnet_id="subnetId",
                transit_gateway_attachment_id="transitGatewayAttachmentId",
                transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3552eb0df4cf839ac449cb4b37583397c280fb505107205f64efd6cc374816f)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument transit_gateway_attachment_id", value=transit_gateway_attachment_id, expected_type=type_hints["transit_gateway_attachment_id"])
            check_type(argname="argument transit_gateway_multicast_domain_id", value=transit_gateway_multicast_domain_id, expected_type=type_hints["transit_gateway_multicast_domain_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
            "transit_gateway_attachment_id": transit_gateway_attachment_id,
            "transit_gateway_multicast_domain_id": transit_gateway_multicast_domain_id,
        }

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The IDs of the subnets to associate with the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomainassociation.html#cfn-ec2-transitgatewaymulticastdomainassociation-subnetid
        '''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomainassociation.html#cfn-ec2-transitgatewaymulticastdomainassociation-transitgatewayattachmentid
        '''
        result = self._values.get("transit_gateway_attachment_id")
        assert result is not None, "Required property 'transit_gateway_attachment_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomainassociation.html#cfn-ec2-transitgatewaymulticastdomainassociation-transitgatewaymulticastdomainid
        '''
        result = self._values.get("transit_gateway_multicast_domain_id")
        assert result is not None, "Required property 'transit_gateway_multicast_domain_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayMulticastDomainAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastDomainProps",
    jsii_struct_bases=[],
    name_mapping={
        "transit_gateway_id": "transitGatewayId",
        "options": "options",
        "tags": "tags",
    },
)
class CfnTransitGatewayMulticastDomainProps:
    def __init__(
        self,
        *,
        transit_gateway_id: builtins.str,
        options: typing.Any = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayMulticastDomain``.

        :param transit_gateway_id: The ID of the transit gateway.
        :param options: The options for the transit gateway multicast domain. - AutoAcceptSharedAssociations (enable | disable) - Igmpv2Support (enable | disable) - StaticSourcesSupport (enable | disable)
        :param tags: The tags for the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomain.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # options: Any
            
            cfn_transit_gateway_multicast_domain_props = ec2.CfnTransitGatewayMulticastDomainProps(
                transit_gateway_id="transitGatewayId",
            
                # the properties below are optional
                options=options,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82230ee30d4f656c56dc4f383195382be24ba4cb84a6769b37e27109627859b9)
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument options", value=options, expected_type=type_hints["options"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "transit_gateway_id": transit_gateway_id,
        }
        if options is not None:
            self._values["options"] = options
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomain.html#cfn-ec2-transitgatewaymulticastdomain-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        assert result is not None, "Required property 'transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def options(self) -> typing.Any:
        '''The options for the transit gateway multicast domain.

        - AutoAcceptSharedAssociations (enable | disable)
        - Igmpv2Support (enable | disable)
        - StaticSourcesSupport (enable | disable)

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomain.html#cfn-ec2-transitgatewaymulticastdomain-options
        '''
        result = self._values.get("options")
        return typing.cast(typing.Any, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastdomain.html#cfn-ec2-transitgatewaymulticastdomain-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayMulticastDomainProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayMulticastGroupMember(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastGroupMember",
):
    '''Registers members (network interfaces) with the transit gateway multicast group.

    A member is a network interface associated with a supported EC2 instance that receives multicast traffic. For information about supported instances, see `Multicast Consideration <https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-limits.html#multicast-limits>`_ in *Amazon VPC Transit Gateways* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupmember.html
    :cloudformationResource: AWS::EC2::TransitGatewayMulticastGroupMember
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_multicast_group_member = ec2.CfnTransitGatewayMulticastGroupMember(self, "MyCfnTransitGatewayMulticastGroupMember",
            group_ip_address="groupIpAddress",
            network_interface_id="networkInterfaceId",
            transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        group_ip_address: builtins.str,
        network_interface_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param group_ip_address: The IP address assigned to the transit gateway multicast group.
        :param network_interface_id: The group members' network interface IDs to register with the transit gateway multicast group.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__99bbc4a729c6448f66047a945b6965b023880f37f56ada02413a5bb67cb9d13e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayMulticastGroupMemberProps(
            group_ip_address=group_ip_address,
            network_interface_id=network_interface_id,
            transit_gateway_multicast_domain_id=transit_gateway_multicast_domain_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c097197b61ad3a7c542d59d643e97e2cc1c1ce371f1094720515cf18ca39c717)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__80c1403a7c86ad1151669cf1148863c486b7c655147ad39e2241472a0fcde771)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupMember")
    def attr_group_member(self) -> _IResolvable_da3f097b:
        '''Information about the registered transit gateway multicast domain group members.

        :cloudformationAttribute: GroupMember
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrGroupMember"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupSource")
    def attr_group_source(self) -> _IResolvable_da3f097b:
        '''Indicates that the resource is a transit gateway multicast domain group member.

        :cloudformationAttribute: GroupSource
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrGroupSource"))

    @builtins.property
    @jsii.member(jsii_name="attrMemberType")
    def attr_member_type(self) -> builtins.str:
        '''The type of group member, for example static.

        :cloudformationAttribute: MemberType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrMemberType"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceId")
    def attr_resource_id(self) -> builtins.str:
        '''The ID of the resource.

        :cloudformationAttribute: ResourceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceId"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceType")
    def attr_resource_type(self) -> builtins.str:
        '''The type of resource, for example a VPC attachment.

        :cloudformationAttribute: ResourceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceType"))

    @builtins.property
    @jsii.member(jsii_name="attrSourceType")
    def attr_source_type(self) -> builtins.str:
        '''The type of source.

        :cloudformationAttribute: SourceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSourceType"))

    @builtins.property
    @jsii.member(jsii_name="attrSubnetId")
    def attr_subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :cloudformationAttribute: SubnetId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSubnetId"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayAttachmentId")
    def attr_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway attachment.

        :cloudformationAttribute: TransitGatewayAttachmentId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayAttachmentId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="groupIpAddress")
    def group_ip_address(self) -> builtins.str:
        '''The IP address assigned to the transit gateway multicast group.'''
        return typing.cast(builtins.str, jsii.get(self, "groupIpAddress"))

    @group_ip_address.setter
    def group_ip_address(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__78530d4f8b5c66188b11c6b16950cc4eed614d73f18d2dd84182bfb961862baf)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupIpAddress", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        '''The group members' network interface IDs to register with the transit gateway multicast group.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7af02059fff2f36e902ab39c08e172a6e2b18ace987c7090f265862a4b889281)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayMulticastDomainId")
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayMulticastDomainId"))

    @transit_gateway_multicast_domain_id.setter
    def transit_gateway_multicast_domain_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e77f7b712c4fc75388360591aab231a51b7d7231aa3b157ea9ee7598d203ccc8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayMulticastDomainId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastGroupMemberProps",
    jsii_struct_bases=[],
    name_mapping={
        "group_ip_address": "groupIpAddress",
        "network_interface_id": "networkInterfaceId",
        "transit_gateway_multicast_domain_id": "transitGatewayMulticastDomainId",
    },
)
class CfnTransitGatewayMulticastGroupMemberProps:
    def __init__(
        self,
        *,
        group_ip_address: builtins.str,
        network_interface_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayMulticastGroupMember``.

        :param group_ip_address: The IP address assigned to the transit gateway multicast group.
        :param network_interface_id: The group members' network interface IDs to register with the transit gateway multicast group.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupmember.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_multicast_group_member_props = ec2.CfnTransitGatewayMulticastGroupMemberProps(
                group_ip_address="groupIpAddress",
                network_interface_id="networkInterfaceId",
                transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd70ba7cb3d2a5746ba2a553a15b9b126ff0ddf756b290927849ef2f3397e093)
            check_type(argname="argument group_ip_address", value=group_ip_address, expected_type=type_hints["group_ip_address"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument transit_gateway_multicast_domain_id", value=transit_gateway_multicast_domain_id, expected_type=type_hints["transit_gateway_multicast_domain_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "group_ip_address": group_ip_address,
            "network_interface_id": network_interface_id,
            "transit_gateway_multicast_domain_id": transit_gateway_multicast_domain_id,
        }

    @builtins.property
    def group_ip_address(self) -> builtins.str:
        '''The IP address assigned to the transit gateway multicast group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupmember.html#cfn-ec2-transitgatewaymulticastgroupmember-groupipaddress
        '''
        result = self._values.get("group_ip_address")
        assert result is not None, "Required property 'group_ip_address' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def network_interface_id(self) -> builtins.str:
        '''The group members' network interface IDs to register with the transit gateway multicast group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupmember.html#cfn-ec2-transitgatewaymulticastgroupmember-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        assert result is not None, "Required property 'network_interface_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupmember.html#cfn-ec2-transitgatewaymulticastgroupmember-transitgatewaymulticastdomainid
        '''
        result = self._values.get("transit_gateway_multicast_domain_id")
        assert result is not None, "Required property 'transit_gateway_multicast_domain_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayMulticastGroupMemberProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayMulticastGroupSource(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastGroupSource",
):
    '''Registers sources (network interfaces) with the specified transit gateway multicast domain.

    A multicast source is a network interface attached to a supported instance that sends multicast traffic. For information about supported instances, see `Multicast Considerations <https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-limits.html#multicast-limits>`_ in *Amazon VPC Transit Gateways* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupsource.html
    :cloudformationResource: AWS::EC2::TransitGatewayMulticastGroupSource
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_multicast_group_source = ec2.CfnTransitGatewayMulticastGroupSource(self, "MyCfnTransitGatewayMulticastGroupSource",
            group_ip_address="groupIpAddress",
            network_interface_id="networkInterfaceId",
            transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        group_ip_address: builtins.str,
        network_interface_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param group_ip_address: The IP address assigned to the transit gateway multicast group.
        :param network_interface_id: The group sources' network interface IDs to register with the transit gateway multicast group.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__033295de69faa0f195767977908005970da4276d079a9497c1199df0f8a16c25)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayMulticastGroupSourceProps(
            group_ip_address=group_ip_address,
            network_interface_id=network_interface_id,
            transit_gateway_multicast_domain_id=transit_gateway_multicast_domain_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3e12c9566f12b9a0a3346bc3093457a98b4487e8553aba5952f4e7a130f8f74e)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b7c375fcb6e9903091c8860559bb5b928ff22761a9e539f7bbf4589848665708)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupMember")
    def attr_group_member(self) -> _IResolvable_da3f097b:
        '''Information about the registered transit gateway multicast domain group members.

        :cloudformationAttribute: GroupMember
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrGroupMember"))

    @builtins.property
    @jsii.member(jsii_name="attrGroupSource")
    def attr_group_source(self) -> _IResolvable_da3f097b:
        '''Indicates that the resource is a transit gateway group member.

        :cloudformationAttribute: GroupSource
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrGroupSource"))

    @builtins.property
    @jsii.member(jsii_name="attrMemberType")
    def attr_member_type(self) -> builtins.str:
        '''The type of group member, for example static.

        :cloudformationAttribute: MemberType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrMemberType"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceId")
    def attr_resource_id(self) -> builtins.str:
        '''The ID of the resource.

        :cloudformationAttribute: ResourceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceId"))

    @builtins.property
    @jsii.member(jsii_name="attrResourceType")
    def attr_resource_type(self) -> builtins.str:
        '''The type of resource, for example a VPC attachment.

        :cloudformationAttribute: ResourceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrResourceType"))

    @builtins.property
    @jsii.member(jsii_name="attrSourceType")
    def attr_source_type(self) -> builtins.str:
        '''The type of source.

        :cloudformationAttribute: SourceType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSourceType"))

    @builtins.property
    @jsii.member(jsii_name="attrSubnetId")
    def attr_subnet_id(self) -> builtins.str:
        '''The ID of the subnet.

        :cloudformationAttribute: SubnetId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrSubnetId"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayAttachmentId")
    def attr_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway attachment.

        :cloudformationAttribute: TransitGatewayAttachmentId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayAttachmentId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="groupIpAddress")
    def group_ip_address(self) -> builtins.str:
        '''The IP address assigned to the transit gateway multicast group.'''
        return typing.cast(builtins.str, jsii.get(self, "groupIpAddress"))

    @group_ip_address.setter
    def group_ip_address(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6498cc6e10a5b77ffe78f41417b966098b903080b2a6e7d3e00cef7a020c9ad)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "groupIpAddress", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        '''The group sources' network interface IDs to register with the transit gateway multicast group.'''
        return typing.cast(builtins.str, jsii.get(self, "networkInterfaceId"))

    @network_interface_id.setter
    def network_interface_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab6436f7c85afaad9bc4d97cbe548d3fafa4a5784cc1cbb316cff4db39914539)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayMulticastDomainId")
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayMulticastDomainId"))

    @transit_gateway_multicast_domain_id.setter
    def transit_gateway_multicast_domain_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0dd53c8c17c01151422c89f930137b2690bf7fe5921e99a47facf4825c4075c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayMulticastDomainId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayMulticastGroupSourceProps",
    jsii_struct_bases=[],
    name_mapping={
        "group_ip_address": "groupIpAddress",
        "network_interface_id": "networkInterfaceId",
        "transit_gateway_multicast_domain_id": "transitGatewayMulticastDomainId",
    },
)
class CfnTransitGatewayMulticastGroupSourceProps:
    def __init__(
        self,
        *,
        group_ip_address: builtins.str,
        network_interface_id: builtins.str,
        transit_gateway_multicast_domain_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayMulticastGroupSource``.

        :param group_ip_address: The IP address assigned to the transit gateway multicast group.
        :param network_interface_id: The group sources' network interface IDs to register with the transit gateway multicast group.
        :param transit_gateway_multicast_domain_id: The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupsource.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_multicast_group_source_props = ec2.CfnTransitGatewayMulticastGroupSourceProps(
                group_ip_address="groupIpAddress",
                network_interface_id="networkInterfaceId",
                transit_gateway_multicast_domain_id="transitGatewayMulticastDomainId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51fd02bb3cf11b7e0f454e3a7a3e40105c5cd8b9be4cdf8a76b1203549d056a8)
            check_type(argname="argument group_ip_address", value=group_ip_address, expected_type=type_hints["group_ip_address"])
            check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
            check_type(argname="argument transit_gateway_multicast_domain_id", value=transit_gateway_multicast_domain_id, expected_type=type_hints["transit_gateway_multicast_domain_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "group_ip_address": group_ip_address,
            "network_interface_id": network_interface_id,
            "transit_gateway_multicast_domain_id": transit_gateway_multicast_domain_id,
        }

    @builtins.property
    def group_ip_address(self) -> builtins.str:
        '''The IP address assigned to the transit gateway multicast group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupsource.html#cfn-ec2-transitgatewaymulticastgroupsource-groupipaddress
        '''
        result = self._values.get("group_ip_address")
        assert result is not None, "Required property 'group_ip_address' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def network_interface_id(self) -> builtins.str:
        '''The group sources' network interface IDs to register with the transit gateway multicast group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupsource.html#cfn-ec2-transitgatewaymulticastgroupsource-networkinterfaceid
        '''
        result = self._values.get("network_interface_id")
        assert result is not None, "Required property 'network_interface_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_multicast_domain_id(self) -> builtins.str:
        '''The ID of the transit gateway multicast domain.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaymulticastgroupsource.html#cfn-ec2-transitgatewaymulticastgroupsource-transitgatewaymulticastdomainid
        '''
        result = self._values.get("transit_gateway_multicast_domain_id")
        assert result is not None, "Required property 'transit_gateway_multicast_domain_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayMulticastGroupSourceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayPeeringAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayPeeringAttachment",
):
    '''Requests a transit gateway peering attachment between the specified transit gateway (requester) and a peer transit gateway (accepter).

    The peer transit gateway can be in your account or a different AWS account .

    After you create the peering attachment, the owner of the accepter transit gateway must accept the attachment request.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html
    :cloudformationResource: AWS::EC2::TransitGatewayPeeringAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_peering_attachment = ec2.CfnTransitGatewayPeeringAttachment(self, "MyCfnTransitGatewayPeeringAttachment",
            peer_account_id="peerAccountId",
            peer_region="peerRegion",
            peer_transit_gateway_id="peerTransitGatewayId",
            transit_gateway_id="transitGatewayId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        peer_account_id: builtins.str,
        peer_region: builtins.str,
        peer_transit_gateway_id: builtins.str,
        transit_gateway_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param peer_account_id: The ID of the AWS account that owns the transit gateway.
        :param peer_region: The Region of the transit gateway.
        :param peer_transit_gateway_id: The ID of the transit gateway.
        :param transit_gateway_id: The ID of the transit gateway peering attachment.
        :param tags: The tags for the transit gateway peering attachment.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58337585cb89e7f01f2f50074e196aeb221ca4931847f4f774499705b5b35fd8)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayPeeringAttachmentProps(
            peer_account_id=peer_account_id,
            peer_region=peer_region,
            peer_transit_gateway_id=peer_transit_gateway_id,
            transit_gateway_id=transit_gateway_id,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a5484bbc750180ce100bc804b4dae3e7ee77aa25ec433001612e49c3d0fa23d8)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b558709a9876b2f9187525b08893d9c4639b71463ec4fe23054c03115219b259)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The time the transit gateway peering attachment was created.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrState")
    def attr_state(self) -> builtins.str:
        '''The state of the transit gateway peering attachment.

        Note that the ``initiating`` state has been deprecated.

        :cloudformationAttribute: State
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrState"))

    @builtins.property
    @jsii.member(jsii_name="attrStatus")
    def attr_status(self) -> _IResolvable_da3f097b:
        '''The status of the transit gateway peering attachment.

        :cloudformationAttribute: Status
        '''
        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrStatus"))

    @builtins.property
    @jsii.member(jsii_name="attrStatusCode")
    def attr_status_code(self) -> builtins.str:
        '''
        :cloudformationAttribute: Status.Code
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatusCode"))

    @builtins.property
    @jsii.member(jsii_name="attrStatusMessage")
    def attr_status_message(self) -> builtins.str:
        '''
        :cloudformationAttribute: Status.Message
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatusMessage"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayAttachmentId")
    def attr_transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the transit gateway peering attachment.

        :cloudformationAttribute: TransitGatewayAttachmentId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayAttachmentId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="peerAccountId")
    def peer_account_id(self) -> builtins.str:
        '''The ID of the AWS account that owns the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "peerAccountId"))

    @peer_account_id.setter
    def peer_account_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d86882413a5d67b4b8f9d3972f68fa0b4000f6a38c663786d27105de7eaa82ee)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerAccountId", value)

    @builtins.property
    @jsii.member(jsii_name="peerRegion")
    def peer_region(self) -> builtins.str:
        '''The Region of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "peerRegion"))

    @peer_region.setter
    def peer_region(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3153fff3ae72085d503742fb48a25c1343bcbc7312bff8131485df03e8a429ed)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerRegion", value)

    @builtins.property
    @jsii.member(jsii_name="peerTransitGatewayId")
    def peer_transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "peerTransitGatewayId"))

    @peer_transit_gateway_id.setter
    def peer_transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__742e838e1128a9b5b4944ce0e33653f15a4c48a8e34db83202b2c6ad727d2e28)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerTransitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway peering attachment.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf14462b6be63c62e19ee63dc199ef02d6cdda10ef2d6938bd0c455e676e87d3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway peering attachment.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d52cd680317a66c5009e2e4fa9defa1bbb3dd9788b6d34f1684c63a8485c4be)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayPeeringAttachment.PeeringAttachmentStatusProperty",
        jsii_struct_bases=[],
        name_mapping={"code": "code", "message": "message"},
    )
    class PeeringAttachmentStatusProperty:
        def __init__(
            self,
            *,
            code: typing.Optional[builtins.str] = None,
            message: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The status of the transit gateway peering attachment.

            :param code: The status code.
            :param message: The status message, if applicable.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaypeeringattachment-peeringattachmentstatus.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                peering_attachment_status_property = ec2.CfnTransitGatewayPeeringAttachment.PeeringAttachmentStatusProperty(
                    code="code",
                    message="message"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__402682d9bd66852b5382ade3d50e18ef97fa5a0a5a922eda3b43c8a76a106784)
                check_type(argname="argument code", value=code, expected_type=type_hints["code"])
                check_type(argname="argument message", value=message, expected_type=type_hints["message"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if code is not None:
                self._values["code"] = code
            if message is not None:
                self._values["message"] = message

        @builtins.property
        def code(self) -> typing.Optional[builtins.str]:
            '''The status code.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaypeeringattachment-peeringattachmentstatus.html#cfn-ec2-transitgatewaypeeringattachment-peeringattachmentstatus-code
            '''
            result = self._values.get("code")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def message(self) -> typing.Optional[builtins.str]:
            '''The status message, if applicable.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewaypeeringattachment-peeringattachmentstatus.html#cfn-ec2-transitgatewaypeeringattachment-peeringattachmentstatus-message
            '''
            result = self._values.get("message")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "PeeringAttachmentStatusProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayPeeringAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "peer_account_id": "peerAccountId",
        "peer_region": "peerRegion",
        "peer_transit_gateway_id": "peerTransitGatewayId",
        "transit_gateway_id": "transitGatewayId",
        "tags": "tags",
    },
)
class CfnTransitGatewayPeeringAttachmentProps:
    def __init__(
        self,
        *,
        peer_account_id: builtins.str,
        peer_region: builtins.str,
        peer_transit_gateway_id: builtins.str,
        transit_gateway_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayPeeringAttachment``.

        :param peer_account_id: The ID of the AWS account that owns the transit gateway.
        :param peer_region: The Region of the transit gateway.
        :param peer_transit_gateway_id: The ID of the transit gateway.
        :param transit_gateway_id: The ID of the transit gateway peering attachment.
        :param tags: The tags for the transit gateway peering attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_peering_attachment_props = ec2.CfnTransitGatewayPeeringAttachmentProps(
                peer_account_id="peerAccountId",
                peer_region="peerRegion",
                peer_transit_gateway_id="peerTransitGatewayId",
                transit_gateway_id="transitGatewayId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__77448e48b8cf8aa3a47158e6a9f13835a48a2d953e7a008d85d4ad77353438ad)
            check_type(argname="argument peer_account_id", value=peer_account_id, expected_type=type_hints["peer_account_id"])
            check_type(argname="argument peer_region", value=peer_region, expected_type=type_hints["peer_region"])
            check_type(argname="argument peer_transit_gateway_id", value=peer_transit_gateway_id, expected_type=type_hints["peer_transit_gateway_id"])
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "peer_account_id": peer_account_id,
            "peer_region": peer_region,
            "peer_transit_gateway_id": peer_transit_gateway_id,
            "transit_gateway_id": transit_gateway_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def peer_account_id(self) -> builtins.str:
        '''The ID of the AWS account that owns the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html#cfn-ec2-transitgatewaypeeringattachment-peeraccountid
        '''
        result = self._values.get("peer_account_id")
        assert result is not None, "Required property 'peer_account_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def peer_region(self) -> builtins.str:
        '''The Region of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html#cfn-ec2-transitgatewaypeeringattachment-peerregion
        '''
        result = self._values.get("peer_region")
        assert result is not None, "Required property 'peer_region' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def peer_transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html#cfn-ec2-transitgatewaypeeringattachment-peertransitgatewayid
        '''
        result = self._values.get("peer_transit_gateway_id")
        assert result is not None, "Required property 'peer_transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway peering attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html#cfn-ec2-transitgatewaypeeringattachment-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        assert result is not None, "Required property 'transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway peering attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewaypeeringattachment.html#cfn-ec2-transitgatewaypeeringattachment-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayPeeringAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayProps",
    jsii_struct_bases=[],
    name_mapping={
        "amazon_side_asn": "amazonSideAsn",
        "association_default_route_table_id": "associationDefaultRouteTableId",
        "auto_accept_shared_attachments": "autoAcceptSharedAttachments",
        "default_route_table_association": "defaultRouteTableAssociation",
        "default_route_table_propagation": "defaultRouteTablePropagation",
        "description": "description",
        "dns_support": "dnsSupport",
        "multicast_support": "multicastSupport",
        "propagation_default_route_table_id": "propagationDefaultRouteTableId",
        "tags": "tags",
        "transit_gateway_cidr_blocks": "transitGatewayCidrBlocks",
        "vpn_ecmp_support": "vpnEcmpSupport",
    },
)
class CfnTransitGatewayProps:
    def __init__(
        self,
        *,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
        association_default_route_table_id: typing.Optional[builtins.str] = None,
        auto_accept_shared_attachments: typing.Optional[builtins.str] = None,
        default_route_table_association: typing.Optional[builtins.str] = None,
        default_route_table_propagation: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_support: typing.Optional[builtins.str] = None,
        multicast_support: typing.Optional[builtins.str] = None,
        propagation_default_route_table_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transit_gateway_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        vpn_ecmp_support: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGateway``.

        :param amazon_side_asn: A private Autonomous System Number (ASN) for the Amazon side of a BGP session. The range is 64512 to 65534 for 16-bit ASNs. The default is 64512.
        :param association_default_route_table_id: The ID of the default association route table.
        :param auto_accept_shared_attachments: Enable or disable automatic acceptance of attachment requests. Disabled by default.
        :param default_route_table_association: Enable or disable automatic association with the default association route table. Enabled by default.
        :param default_route_table_propagation: Enable or disable automatic propagation of routes to the default propagation route table. Enabled by default.
        :param description: The description of the transit gateway.
        :param dns_support: Enable or disable DNS support. Enabled by default.
        :param multicast_support: Indicates whether multicast is enabled on the transit gateway.
        :param propagation_default_route_table_id: The ID of the default propagation route table.
        :param tags: The tags for the transit gateway.
        :param transit_gateway_cidr_blocks: The transit gateway CIDR blocks.
        :param vpn_ecmp_support: Enable or disable Equal Cost Multipath Protocol support. Enabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_props = ec2.CfnTransitGatewayProps(
                amazon_side_asn=123,
                association_default_route_table_id="associationDefaultRouteTableId",
                auto_accept_shared_attachments="autoAcceptSharedAttachments",
                default_route_table_association="defaultRouteTableAssociation",
                default_route_table_propagation="defaultRouteTablePropagation",
                description="description",
                dns_support="dnsSupport",
                multicast_support="multicastSupport",
                propagation_default_route_table_id="propagationDefaultRouteTableId",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                transit_gateway_cidr_blocks=["transitGatewayCidrBlocks"],
                vpn_ecmp_support="vpnEcmpSupport"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__49fd996c8de156c654fbaab604bd7c39350335d42f26ebf85fab17421d12904e)
            check_type(argname="argument amazon_side_asn", value=amazon_side_asn, expected_type=type_hints["amazon_side_asn"])
            check_type(argname="argument association_default_route_table_id", value=association_default_route_table_id, expected_type=type_hints["association_default_route_table_id"])
            check_type(argname="argument auto_accept_shared_attachments", value=auto_accept_shared_attachments, expected_type=type_hints["auto_accept_shared_attachments"])
            check_type(argname="argument default_route_table_association", value=default_route_table_association, expected_type=type_hints["default_route_table_association"])
            check_type(argname="argument default_route_table_propagation", value=default_route_table_propagation, expected_type=type_hints["default_route_table_propagation"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument dns_support", value=dns_support, expected_type=type_hints["dns_support"])
            check_type(argname="argument multicast_support", value=multicast_support, expected_type=type_hints["multicast_support"])
            check_type(argname="argument propagation_default_route_table_id", value=propagation_default_route_table_id, expected_type=type_hints["propagation_default_route_table_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument transit_gateway_cidr_blocks", value=transit_gateway_cidr_blocks, expected_type=type_hints["transit_gateway_cidr_blocks"])
            check_type(argname="argument vpn_ecmp_support", value=vpn_ecmp_support, expected_type=type_hints["vpn_ecmp_support"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if amazon_side_asn is not None:
            self._values["amazon_side_asn"] = amazon_side_asn
        if association_default_route_table_id is not None:
            self._values["association_default_route_table_id"] = association_default_route_table_id
        if auto_accept_shared_attachments is not None:
            self._values["auto_accept_shared_attachments"] = auto_accept_shared_attachments
        if default_route_table_association is not None:
            self._values["default_route_table_association"] = default_route_table_association
        if default_route_table_propagation is not None:
            self._values["default_route_table_propagation"] = default_route_table_propagation
        if description is not None:
            self._values["description"] = description
        if dns_support is not None:
            self._values["dns_support"] = dns_support
        if multicast_support is not None:
            self._values["multicast_support"] = multicast_support
        if propagation_default_route_table_id is not None:
            self._values["propagation_default_route_table_id"] = propagation_default_route_table_id
        if tags is not None:
            self._values["tags"] = tags
        if transit_gateway_cidr_blocks is not None:
            self._values["transit_gateway_cidr_blocks"] = transit_gateway_cidr_blocks
        if vpn_ecmp_support is not None:
            self._values["vpn_ecmp_support"] = vpn_ecmp_support

    @builtins.property
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''A private Autonomous System Number (ASN) for the Amazon side of a BGP session.

        The range is 64512 to 65534 for 16-bit ASNs. The default is 64512.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-amazonsideasn
        '''
        result = self._values.get("amazon_side_asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def association_default_route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the default association route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-associationdefaultroutetableid
        '''
        result = self._values.get("association_default_route_table_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def auto_accept_shared_attachments(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic acceptance of attachment requests.

        Disabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-autoacceptsharedattachments
        '''
        result = self._values.get("auto_accept_shared_attachments")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def default_route_table_association(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic association with the default association route table.

        Enabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-defaultroutetableassociation
        '''
        result = self._values.get("default_route_table_association")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def default_route_table_propagation(self) -> typing.Optional[builtins.str]:
        '''Enable or disable automatic propagation of routes to the default propagation route table.

        Enabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-defaultroutetablepropagation
        '''
        result = self._values.get("default_route_table_propagation")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''The description of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dns_support(self) -> typing.Optional[builtins.str]:
        '''Enable or disable DNS support.

        Enabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-dnssupport
        '''
        result = self._values.get("dns_support")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def multicast_support(self) -> typing.Optional[builtins.str]:
        '''Indicates whether multicast is enabled on the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-multicastsupport
        '''
        result = self._values.get("multicast_support")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def propagation_default_route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the default propagation route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-propagationdefaultroutetableid
        '''
        result = self._values.get("propagation_default_route_table_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def transit_gateway_cidr_blocks(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The transit gateway CIDR blocks.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-transitgatewaycidrblocks
        '''
        result = self._values.get("transit_gateway_cidr_blocks")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def vpn_ecmp_support(self) -> typing.Optional[builtins.str]:
        '''Enable or disable Equal Cost Multipath Protocol support.

        Enabled by default.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgateway.html#cfn-ec2-transitgateway-vpnecmpsupport
        '''
        result = self._values.get("vpn_ecmp_support")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayRoute(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRoute",
):
    '''Specifies a static route for a transit gateway route table.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html
    :cloudformationResource: AWS::EC2::TransitGatewayRoute
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_route = ec2.CfnTransitGatewayRoute(self, "MyCfnTransitGatewayRoute",
            transit_gateway_route_table_id="transitGatewayRouteTableId",
        
            # the properties below are optional
            blackhole=False,
            destination_cidr_block="destinationCidrBlock",
            transit_gateway_attachment_id="transitGatewayAttachmentId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        transit_gateway_route_table_id: builtins.str,
        blackhole: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        destination_cidr_block: typing.Optional[builtins.str] = None,
        transit_gateway_attachment_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param transit_gateway_route_table_id: The ID of the transit gateway route table.
        :param blackhole: Indicates whether to drop traffic that matches this route.
        :param destination_cidr_block: The CIDR block used for destination matches.
        :param transit_gateway_attachment_id: The ID of the attachment.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__762528618652de53ec01b9db873d15c1412ef510b68d36faf8e5193eec412419)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayRouteProps(
            transit_gateway_route_table_id=transit_gateway_route_table_id,
            blackhole=blackhole,
            destination_cidr_block=destination_cidr_block,
            transit_gateway_attachment_id=transit_gateway_attachment_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6fe5f8903bb547777e371b24127245fea55b6701396307b362c9f6bcd40be6ea)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__db248da6e580b35319fa4105c6aa56b32a97434942c5e6aa6364835dd97a2da2)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="transitGatewayRouteTableId")
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the transit gateway route table.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayRouteTableId"))

    @transit_gateway_route_table_id.setter
    def transit_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a3ff43d5668d80486662b5f29a818edf8b7a164143e8327503af53fea81d72e4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayRouteTableId", value)

    @builtins.property
    @jsii.member(jsii_name="blackhole")
    def blackhole(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to drop traffic that matches this route.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "blackhole"))

    @blackhole.setter
    def blackhole(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae3c350b4ebbf2eafd4fffaf648073580cc8872edfcbb0622e12224667970a75)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "blackhole", value)

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The CIDR block used for destination matches.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30150d874e802337a21fe5c33c5e59055a33af9ec33282c5c08706bcd1082c1c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the attachment.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "transitGatewayAttachmentId"))

    @transit_gateway_attachment_id.setter
    def transit_gateway_attachment_id(
        self,
        value: typing.Optional[builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a94dba0eae14b14a0b432cb7e86de53fbec80e85adaa717d318a1fe9f54f5a15)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayAttachmentId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteProps",
    jsii_struct_bases=[],
    name_mapping={
        "transit_gateway_route_table_id": "transitGatewayRouteTableId",
        "blackhole": "blackhole",
        "destination_cidr_block": "destinationCidrBlock",
        "transit_gateway_attachment_id": "transitGatewayAttachmentId",
    },
)
class CfnTransitGatewayRouteProps:
    def __init__(
        self,
        *,
        transit_gateway_route_table_id: builtins.str,
        blackhole: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        destination_cidr_block: typing.Optional[builtins.str] = None,
        transit_gateway_attachment_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayRoute``.

        :param transit_gateway_route_table_id: The ID of the transit gateway route table.
        :param blackhole: Indicates whether to drop traffic that matches this route.
        :param destination_cidr_block: The CIDR block used for destination matches.
        :param transit_gateway_attachment_id: The ID of the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_route_props = ec2.CfnTransitGatewayRouteProps(
                transit_gateway_route_table_id="transitGatewayRouteTableId",
            
                # the properties below are optional
                blackhole=False,
                destination_cidr_block="destinationCidrBlock",
                transit_gateway_attachment_id="transitGatewayAttachmentId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__234e56a6f757b6cae89b22252317937e5caf6081f899789f9dfaf239987ad5e3)
            check_type(argname="argument transit_gateway_route_table_id", value=transit_gateway_route_table_id, expected_type=type_hints["transit_gateway_route_table_id"])
            check_type(argname="argument blackhole", value=blackhole, expected_type=type_hints["blackhole"])
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument transit_gateway_attachment_id", value=transit_gateway_attachment_id, expected_type=type_hints["transit_gateway_attachment_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "transit_gateway_route_table_id": transit_gateway_route_table_id,
        }
        if blackhole is not None:
            self._values["blackhole"] = blackhole
        if destination_cidr_block is not None:
            self._values["destination_cidr_block"] = destination_cidr_block
        if transit_gateway_attachment_id is not None:
            self._values["transit_gateway_attachment_id"] = transit_gateway_attachment_id

    @builtins.property
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the transit gateway route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html#cfn-ec2-transitgatewayroute-transitgatewayroutetableid
        '''
        result = self._values.get("transit_gateway_route_table_id")
        assert result is not None, "Required property 'transit_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def blackhole(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to drop traffic that matches this route.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html#cfn-ec2-transitgatewayroute-blackhole
        '''
        result = self._values.get("blackhole")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def destination_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The CIDR block used for destination matches.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html#cfn-ec2-transitgatewayroute-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def transit_gateway_attachment_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroute.html#cfn-ec2-transitgatewayroute-transitgatewayattachmentid
        '''
        result = self._values.get("transit_gateway_attachment_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayRouteTable(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTable",
):
    '''Specifies a route table for a transit gateway.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetable.html
    :cloudformationResource: AWS::EC2::TransitGatewayRouteTable
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_route_table = ec2.CfnTransitGatewayRouteTable(self, "MyCfnTransitGatewayRouteTable",
            transit_gateway_id="transitGatewayId",
        
            # the properties below are optional
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        transit_gateway_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param transit_gateway_id: The ID of the transit gateway.
        :param tags: Any tags assigned to the route table.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c7db50f4ae112c57ab046bda7776d377180bab25c5b7569cfacb2c8fd614844)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayRouteTableProps(
            transit_gateway_id=transit_gateway_id, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d88de7ca145b9691c5f4568e02636aa128bc669dce28368c24b0f50acbf21749)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__93d1caddf8f58dd830a8b1a8588a6e19085533263b68967e0f81ecc59cc99e29)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrTransitGatewayRouteTableId")
    def attr_transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the transit gateway route table.

        :cloudformationAttribute: TransitGatewayRouteTableId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrTransitGatewayRouteTableId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5290db479c4c53b82c25594d079582d552d1268cad24e1cfbd7651525fbb11df)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the route table.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__43aeed96c5f9dc7ad9fd30a7b025d18beeafc24b1e18d45dd7f55535f13a095f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayRouteTableAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTableAssociation",
):
    '''Associates the specified attachment with the specified transit gateway route table.

    You can associate one route table with an attachment.

    Before you can update the route table associated with an attachment, you must disassociate the transit gateway route table that is currently associated with the attachment. First update the stack to remove the associated transit gateway route table, and then update the stack with the ID of the new transit gateway route table to associate.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetableassociation.html
    :cloudformationResource: AWS::EC2::TransitGatewayRouteTableAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_route_table_association = ec2.CfnTransitGatewayRouteTableAssociation(self, "MyCfnTransitGatewayRouteTableAssociation",
            transit_gateway_attachment_id="transitGatewayAttachmentId",
            transit_gateway_route_table_id="transitGatewayRouteTableId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_route_table_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param transit_gateway_attachment_id: The ID of the attachment.
        :param transit_gateway_route_table_id: The ID of the route table for the transit gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__78f986e9d5f6aaaab639684e8a0a0fcd849e66ee5753c55924b5eada37d47009)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayRouteTableAssociationProps(
            transit_gateway_attachment_id=transit_gateway_attachment_id,
            transit_gateway_route_table_id=transit_gateway_route_table_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__116daffc777588d4dfa146f91ca3900babc69bf1e2175e3ad761bdd21884e7b5)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08b6fb4f1eaecedb0dfe89b77727aba1e81188951720ea798d7fa437604e9558)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayAttachmentId"))

    @transit_gateway_attachment_id.setter
    def transit_gateway_attachment_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5543e31dfb20c6968b1e8209ff4712412a0d6c761e4ea9efc49f5770988c52d0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayAttachmentId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayRouteTableId")
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the route table for the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayRouteTableId"))

    @transit_gateway_route_table_id.setter
    def transit_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74675d79a411337f3a445f03fad9f4be2bd700c99ec19055fba1046f2ed4a907)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayRouteTableId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTableAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "transit_gateway_attachment_id": "transitGatewayAttachmentId",
        "transit_gateway_route_table_id": "transitGatewayRouteTableId",
    },
)
class CfnTransitGatewayRouteTableAssociationProps:
    def __init__(
        self,
        *,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_route_table_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayRouteTableAssociation``.

        :param transit_gateway_attachment_id: The ID of the attachment.
        :param transit_gateway_route_table_id: The ID of the route table for the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetableassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_route_table_association_props = ec2.CfnTransitGatewayRouteTableAssociationProps(
                transit_gateway_attachment_id="transitGatewayAttachmentId",
                transit_gateway_route_table_id="transitGatewayRouteTableId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4829b3291359a71c64898c4281f04e83bed2de8afe12ff66a4133e08152d9810)
            check_type(argname="argument transit_gateway_attachment_id", value=transit_gateway_attachment_id, expected_type=type_hints["transit_gateway_attachment_id"])
            check_type(argname="argument transit_gateway_route_table_id", value=transit_gateway_route_table_id, expected_type=type_hints["transit_gateway_route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "transit_gateway_attachment_id": transit_gateway_attachment_id,
            "transit_gateway_route_table_id": transit_gateway_route_table_id,
        }

    @builtins.property
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetableassociation.html#cfn-ec2-transitgatewayroutetableassociation-transitgatewayattachmentid
        '''
        result = self._values.get("transit_gateway_attachment_id")
        assert result is not None, "Required property 'transit_gateway_attachment_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the route table for the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetableassociation.html#cfn-ec2-transitgatewayroutetableassociation-transitgatewayroutetableid
        '''
        result = self._values.get("transit_gateway_route_table_id")
        assert result is not None, "Required property 'transit_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayRouteTableAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnTransitGatewayRouteTablePropagation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTablePropagation",
):
    '''Enables the specified attachment to propagate routes to the specified propagation route table.

    For more information about enabling transit gateway route propagation, see `EnableTransitGatewayRouteTablePropagation <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableTransitGatewayRouteTablePropagation.html>`_ in the *Amazon EC2 API Reference* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetablepropagation.html
    :cloudformationResource: AWS::EC2::TransitGatewayRouteTablePropagation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_transit_gateway_route_table_propagation = ec2.CfnTransitGatewayRouteTablePropagation(self, "MyCfnTransitGatewayRouteTablePropagation",
            transit_gateway_attachment_id="transitGatewayAttachmentId",
            transit_gateway_route_table_id="transitGatewayRouteTableId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_route_table_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param transit_gateway_attachment_id: The ID of the attachment.
        :param transit_gateway_route_table_id: The ID of the propagation route table.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da858a31988874f473110279ec5eb87449e233a3ebad68452008972c2f671d23)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayRouteTablePropagationProps(
            transit_gateway_attachment_id=transit_gateway_attachment_id,
            transit_gateway_route_table_id=transit_gateway_route_table_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d5810e45fa905e8749c88f944f6da27be097fce5be9b460b8f4f7daf3be4a6e)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82640e3148a89b50ab9fa60ce3c86b0e17db3d883834214fff5e89af89d28710)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayAttachmentId"))

    @transit_gateway_attachment_id.setter
    def transit_gateway_attachment_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf4acf2c9e41294be87e18f515bafd4da46d18ee8cd9a84954cef588d027cee6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayAttachmentId", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayRouteTableId")
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the propagation route table.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayRouteTableId"))

    @transit_gateway_route_table_id.setter
    def transit_gateway_route_table_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b58bce0f83d6f5219bc4748ef214de49ff2150073c9cd7d3c6dd566f5ccff2fd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayRouteTableId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTablePropagationProps",
    jsii_struct_bases=[],
    name_mapping={
        "transit_gateway_attachment_id": "transitGatewayAttachmentId",
        "transit_gateway_route_table_id": "transitGatewayRouteTableId",
    },
)
class CfnTransitGatewayRouteTablePropagationProps:
    def __init__(
        self,
        *,
        transit_gateway_attachment_id: builtins.str,
        transit_gateway_route_table_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayRouteTablePropagation``.

        :param transit_gateway_attachment_id: The ID of the attachment.
        :param transit_gateway_route_table_id: The ID of the propagation route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetablepropagation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_route_table_propagation_props = ec2.CfnTransitGatewayRouteTablePropagationProps(
                transit_gateway_attachment_id="transitGatewayAttachmentId",
                transit_gateway_route_table_id="transitGatewayRouteTableId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1001c0cdbacafaaf2659cb8ad44ad98feae866d7909c2d8fe15588f9385bba8)
            check_type(argname="argument transit_gateway_attachment_id", value=transit_gateway_attachment_id, expected_type=type_hints["transit_gateway_attachment_id"])
            check_type(argname="argument transit_gateway_route_table_id", value=transit_gateway_route_table_id, expected_type=type_hints["transit_gateway_route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "transit_gateway_attachment_id": transit_gateway_attachment_id,
            "transit_gateway_route_table_id": transit_gateway_route_table_id,
        }

    @builtins.property
    def transit_gateway_attachment_id(self) -> builtins.str:
        '''The ID of the attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetablepropagation.html#cfn-ec2-transitgatewayroutetablepropagation-transitgatewayattachmentid
        '''
        result = self._values.get("transit_gateway_attachment_id")
        assert result is not None, "Required property 'transit_gateway_attachment_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def transit_gateway_route_table_id(self) -> builtins.str:
        '''The ID of the propagation route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetablepropagation.html#cfn-ec2-transitgatewayroutetablepropagation-transitgatewayroutetableid
        '''
        result = self._values.get("transit_gateway_route_table_id")
        assert result is not None, "Required property 'transit_gateway_route_table_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayRouteTablePropagationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayRouteTableProps",
    jsii_struct_bases=[],
    name_mapping={"transit_gateway_id": "transitGatewayId", "tags": "tags"},
)
class CfnTransitGatewayRouteTableProps:
    def __init__(
        self,
        *,
        transit_gateway_id: builtins.str,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayRouteTable``.

        :param transit_gateway_id: The ID of the transit gateway.
        :param tags: Any tags assigned to the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetable.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_transit_gateway_route_table_props = ec2.CfnTransitGatewayRouteTableProps(
                transit_gateway_id="transitGatewayId",
            
                # the properties below are optional
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__624ecdc1b51b6d7cebc10c5a14a95ecb834135c841993042fc7676de30a6ecfd)
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "transit_gateway_id": transit_gateway_id,
        }
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetable.html#cfn-ec2-transitgatewayroutetable-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        assert result is not None, "Required property 'transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the route table.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayroutetable.html#cfn-ec2-transitgatewayroutetable-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayRouteTableProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnTransitGatewayVpcAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayVpcAttachment",
):
    '''Specifies a VPC attachment.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html
    :cloudformationResource: AWS::EC2::TransitGatewayVpcAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # options: Any
        
        cfn_transit_gateway_vpc_attachment = ec2.CfnTransitGatewayVpcAttachment(self, "MyCfnTransitGatewayVpcAttachment",
            subnet_ids=["subnetIds"],
            transit_gateway_id="transitGatewayId",
            vpc_id="vpcId",
        
            # the properties below are optional
            add_subnet_ids=["addSubnetIds"],
            options=options,
            remove_subnet_ids=["removeSubnetIds"],
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_ids: typing.Sequence[builtins.str],
        transit_gateway_id: builtins.str,
        vpc_id: builtins.str,
        add_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        options: typing.Any = None,
        remove_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param subnet_ids: The IDs of the subnets.
        :param transit_gateway_id: The ID of the transit gateway.
        :param vpc_id: The ID of the VPC.
        :param add_subnet_ids: The IDs of one or more subnets to add. You can specify at most one subnet per Availability Zone.
        :param options: The VPC attachment options.
        :param remove_subnet_ids: The IDs of one or more subnets to remove.
        :param tags: The tags for the VPC attachment.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d109d90c87450f0637894d56c9ee177e4beea437893a966e606a7dd2826860b4)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnTransitGatewayVpcAttachmentProps(
            subnet_ids=subnet_ids,
            transit_gateway_id=transit_gateway_id,
            vpc_id=vpc_id,
            add_subnet_ids=add_subnet_ids,
            options=options,
            remove_subnet_ids=remove_subnet_ids,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9ecc0d93af1c8489c4bbda700ff0aaa17993b7f890387763b61be49a669634f3)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8dbd974ae5adbe7b1ad43ec624c5e026d9e8e738560ca2db8fc4cbb519566adc)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the attachment.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="subnetIds")
    def subnet_ids(self) -> typing.List[builtins.str]:
        '''The IDs of the subnets.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "subnetIds"))

    @subnet_ids.setter
    def subnet_ids(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8824c05960be22a88ed38a1107dfdda1b7a33c1130d7345cb45bd41fa07e6fa1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetIds", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__64125fcd948a2b9a2891c0f1b735612475a3696e1e1a6ce222449d816847cf37)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e587353a349767971e5cbaf158300eab82f9bce2692398042f86c980ae2c528c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="addSubnetIds")
    def add_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more subnets to add.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "addSubnetIds"))

    @add_subnet_ids.setter
    def add_subnet_ids(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__afc015eac08ef29fff8117c42a6b139d4590bcd699d2fb2a9fcfe014bcf849a8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "addSubnetIds", value)

    @builtins.property
    @jsii.member(jsii_name="options")
    def options(self) -> typing.Any:
        '''The VPC attachment options.'''
        return typing.cast(typing.Any, jsii.get(self, "options"))

    @options.setter
    def options(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e8c626c0d6f1542c9973dab4d553c5913bd5993d5ed06bf53b5e4da100ed6536)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "options", value)

    @builtins.property
    @jsii.member(jsii_name="removeSubnetIds")
    def remove_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more subnets to remove.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "removeSubnetIds"))

    @remove_subnet_ids.setter
    def remove_subnet_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dee422a132fe5db433448f7d65a42eb23ff4421e51273d7fee8cc820f6191ebb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "removeSubnetIds", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the VPC attachment.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52ea672c76395c2636652dcdf3a840ac98008f0aaef840e1c4223288eb7758ea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayVpcAttachment.OptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "appliance_mode_support": "applianceModeSupport",
            "dns_support": "dnsSupport",
            "ipv6_support": "ipv6Support",
        },
    )
    class OptionsProperty:
        def __init__(
            self,
            *,
            appliance_mode_support: typing.Optional[builtins.str] = None,
            dns_support: typing.Optional[builtins.str] = None,
            ipv6_support: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the VPC attachment options.

            :param appliance_mode_support: Enable or disable appliance mode support. The default is ``disable`` .
            :param dns_support: Enable or disable DNS support. The default is ``disable`` .
            :param ipv6_support: Enable or disable IPv6 support. The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayvpcattachment-options.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                options_property = ec2.CfnTransitGatewayVpcAttachment.OptionsProperty(
                    appliance_mode_support="applianceModeSupport",
                    dns_support="dnsSupport",
                    ipv6_support="ipv6Support"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ea53e7949c27ba728a0fa1f4b7f62f321894de9f55e4d88a106982259092207d)
                check_type(argname="argument appliance_mode_support", value=appliance_mode_support, expected_type=type_hints["appliance_mode_support"])
                check_type(argname="argument dns_support", value=dns_support, expected_type=type_hints["dns_support"])
                check_type(argname="argument ipv6_support", value=ipv6_support, expected_type=type_hints["ipv6_support"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if appliance_mode_support is not None:
                self._values["appliance_mode_support"] = appliance_mode_support
            if dns_support is not None:
                self._values["dns_support"] = dns_support
            if ipv6_support is not None:
                self._values["ipv6_support"] = ipv6_support

        @builtins.property
        def appliance_mode_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable appliance mode support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayvpcattachment-options.html#cfn-ec2-transitgatewayvpcattachment-options-appliancemodesupport
            '''
            result = self._values.get("appliance_mode_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def dns_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable DNS support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayvpcattachment-options.html#cfn-ec2-transitgatewayvpcattachment-options-dnssupport
            '''
            result = self._values.get("dns_support")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def ipv6_support(self) -> typing.Optional[builtins.str]:
            '''Enable or disable IPv6 support.

            The default is ``disable`` .

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-transitgatewayvpcattachment-options.html#cfn-ec2-transitgatewayvpcattachment-options-ipv6support
            '''
            result = self._values.get("ipv6_support")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "OptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnTransitGatewayVpcAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_ids": "subnetIds",
        "transit_gateway_id": "transitGatewayId",
        "vpc_id": "vpcId",
        "add_subnet_ids": "addSubnetIds",
        "options": "options",
        "remove_subnet_ids": "removeSubnetIds",
        "tags": "tags",
    },
)
class CfnTransitGatewayVpcAttachmentProps:
    def __init__(
        self,
        *,
        subnet_ids: typing.Sequence[builtins.str],
        transit_gateway_id: builtins.str,
        vpc_id: builtins.str,
        add_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        options: typing.Any = None,
        remove_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnTransitGatewayVpcAttachment``.

        :param subnet_ids: The IDs of the subnets.
        :param transit_gateway_id: The ID of the transit gateway.
        :param vpc_id: The ID of the VPC.
        :param add_subnet_ids: The IDs of one or more subnets to add. You can specify at most one subnet per Availability Zone.
        :param options: The VPC attachment options.
        :param remove_subnet_ids: The IDs of one or more subnets to remove.
        :param tags: The tags for the VPC attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # options: Any
            
            cfn_transit_gateway_vpc_attachment_props = ec2.CfnTransitGatewayVpcAttachmentProps(
                subnet_ids=["subnetIds"],
                transit_gateway_id="transitGatewayId",
                vpc_id="vpcId",
            
                # the properties below are optional
                add_subnet_ids=["addSubnetIds"],
                options=options,
                remove_subnet_ids=["removeSubnetIds"],
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5b00816ee380c391f9918e8b3c6ac6b403ffa259db4a3b55f9792a5841c334ec)
            check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument add_subnet_ids", value=add_subnet_ids, expected_type=type_hints["add_subnet_ids"])
            check_type(argname="argument options", value=options, expected_type=type_hints["options"])
            check_type(argname="argument remove_subnet_ids", value=remove_subnet_ids, expected_type=type_hints["remove_subnet_ids"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_ids": subnet_ids,
            "transit_gateway_id": transit_gateway_id,
            "vpc_id": vpc_id,
        }
        if add_subnet_ids is not None:
            self._values["add_subnet_ids"] = add_subnet_ids
        if options is not None:
            self._values["options"] = options
        if remove_subnet_ids is not None:
            self._values["remove_subnet_ids"] = remove_subnet_ids
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def subnet_ids(self) -> typing.List[builtins.str]:
        '''The IDs of the subnets.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-subnetids
        '''
        result = self._values.get("subnet_ids")
        assert result is not None, "Required property 'subnet_ids' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def transit_gateway_id(self) -> builtins.str:
        '''The ID of the transit gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        assert result is not None, "Required property 'transit_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def add_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more subnets to add.

        You can specify at most one subnet per Availability Zone.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-addsubnetids
        '''
        result = self._values.get("add_subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def options(self) -> typing.Any:
        '''The VPC attachment options.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-options
        '''
        result = self._values.get("options")
        return typing.cast(typing.Any, result)

    @builtins.property
    def remove_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of one or more subnets to remove.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-removesubnetids
        '''
        result = self._values.get("remove_subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the VPC attachment.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-transitgatewayvpcattachment.html#cfn-ec2-transitgatewayvpcattachment-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnTransitGatewayVpcAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVPC(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPC",
):
    '''Specifies a virtual private cloud (VPC).

    To add an IPv6 CIDR block to the VPC, see `AWS::EC2::VPCCidrBlock <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html>`_ .

    For more information, see `Virtual private clouds (VPC) <https://docs.aws.amazon.com/vpc/latest/userguide/configure-your-vpc.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html
    :cloudformationResource: AWS::EC2::VPC
    :exampleMetadata: infused

    Example::

        # cfn_template: cfn_inc.CfnInclude
        
        # using from*Attributes()
        # private_cfn_subnet1: ec2.CfnSubnet
        # private_cfn_subnet2: ec2.CfnSubnet
        
        
        # using from*Name()
        cfn_bucket = cfn_template.get_resource("Bucket")
        bucket = s3.Bucket.from_bucket_name(self, "L2Bucket", cfn_bucket.ref)
        
        # using from*Arn()
        cfn_key = cfn_template.get_resource("Key")
        key = kms.Key.from_key_arn(self, "L2Key", cfn_key.attr_arn)
        cfn_vpc = cfn_template.get_resource("Vpc")
        vpc = ec2.Vpc.from_vpc_attributes(self, "L2Vpc",
            vpc_id=cfn_vpc.ref,
            availability_zones=core.Fn.get_azs(),
            private_subnet_ids=[private_cfn_subnet1.ref, private_cfn_subnet2.ref]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        cidr_block: typing.Optional[builtins.str] = None,
        enable_dns_hostnames: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        enable_dns_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        instance_tenancy: typing.Optional[builtins.str] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param cidr_block: The IPv4 network range for the VPC, in CIDR notation. For example, ``10.0.0.0/16`` . 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`` . You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .
        :param enable_dns_hostnames: Indicates whether the instances launched in the VPC get DNS hostnames. If enabled, instances in the VPC get DNS hostnames; otherwise, they do not. Disabled by default for nondefault VPCs. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ . You can only enable DNS hostnames if you've enabled DNS support.
        :param enable_dns_support: Indicates whether the DNS resolution is supported for the VPC. If enabled, queries to the Amazon provided DNS server at the 169.254.169.253 IP address, or the reserved IP address at the base of the VPC network range "plus two" succeed. If disabled, the Amazon provided DNS service in the VPC that resolves public DNS hostnames to IP addresses is not enabled. Enabled by default. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ .
        :param instance_tenancy: The allowed tenancy of instances launched into the VPC. - ``default`` : An instance launched into the VPC runs on shared hardware by default, unless you explicitly specify a different tenancy during instance launch. - ``dedicated`` : An instance launched into the VPC runs on dedicated hardware by default, unless you explicitly specify a tenancy of ``host`` during instance launch. You cannot specify a tenancy of ``default`` during instance launch. Updating ``InstanceTenancy`` requires no replacement only if you are updating its value from ``dedicated`` to ``default`` . Updating ``InstanceTenancy`` from ``default`` to ``dedicated`` requires replacement.
        :param ipv4_ipam_pool_id: The ID of an IPv4 IPAM pool you want to use for allocating this VPC's CIDR. For more information, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* . You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .
        :param ipv4_netmask_length: The netmask length of the IPv4 CIDR you want to allocate to this VPC from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param tags: The tags for the VPC.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__652142f8451c882a92006b3da83dda7c75035b0e67cfdb89b2dafff72755d8a2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCProps(
            cidr_block=cidr_block,
            enable_dns_hostnames=enable_dns_hostnames,
            enable_dns_support=enable_dns_support,
            instance_tenancy=instance_tenancy,
            ipv4_ipam_pool_id=ipv4_ipam_pool_id,
            ipv4_netmask_length=ipv4_netmask_length,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a3738c2c36e6ee829580f25d486aedc44b115450b8ef5d1ad87f9e8ea4c37f38)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e488342c955b8d1ac0d4c25b5ef0a38de7c0fb0c580635703e6a0b5431f3a83d)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCidrBlock")
    def attr_cidr_block(self) -> builtins.str:
        '''The primary IPv4 CIDR block for the VPC.

        For example, 10.0.0.0/16.

        :cloudformationAttribute: CidrBlock
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="attrCidrBlockAssociations")
    def attr_cidr_block_associations(self) -> typing.List[builtins.str]:
        '''The association IDs of the IPv4 CIDR blocks for the VPC.

        For example, [ vpc-cidr-assoc-0280ab6b ].

        :cloudformationAttribute: CidrBlockAssociations
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrCidrBlockAssociations"))

    @builtins.property
    @jsii.member(jsii_name="attrDefaultNetworkAcl")
    def attr_default_network_acl(self) -> builtins.str:
        '''The ID of the default network ACL for the VPC.

        For example, acl-814dafe3.

        :cloudformationAttribute: DefaultNetworkAcl
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDefaultNetworkAcl"))

    @builtins.property
    @jsii.member(jsii_name="attrDefaultSecurityGroup")
    def attr_default_security_group(self) -> builtins.str:
        '''The ID of the default security group for the VPC.

        For example, sg-b178e0d3.

        :cloudformationAttribute: DefaultSecurityGroup
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDefaultSecurityGroup"))

    @builtins.property
    @jsii.member(jsii_name="attrIpv6CidrBlocks")
    def attr_ipv6_cidr_blocks(self) -> typing.List[builtins.str]:
        '''The IPv6 CIDR blocks for the VPC.

        For example, [ 2001:db8:1234:1a00::/56 ].

        :cloudformationAttribute: Ipv6CidrBlocks
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrIpv6CidrBlocks"))

    @builtins.property
    @jsii.member(jsii_name="attrVpcId")
    def attr_vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :cloudformationAttribute: VpcId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpcId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="cidrBlock")
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 network range for the VPC, in CIDR notation.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrBlock"))

    @cidr_block.setter
    def cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6676074ad3966d5d24524535dac1f0683a56ce312fe3dc7ec544a0708301ad33)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="enableDnsHostnames")
    def enable_dns_hostnames(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the instances launched in the VPC get DNS hostnames.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "enableDnsHostnames"))

    @enable_dns_hostnames.setter
    def enable_dns_hostnames(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76b1c3d147ac864c2bd493d268192b99f69e4ff3aeb1a1783954d1efa7c0ecce)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enableDnsHostnames", value)

    @builtins.property
    @jsii.member(jsii_name="enableDnsSupport")
    def enable_dns_support(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the DNS resolution is supported for the VPC.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "enableDnsSupport"))

    @enable_dns_support.setter
    def enable_dns_support(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3645a4a353e587b21e1cd795ce82fc78aaea171258b387dcdf1e200a803e1e2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enableDnsSupport", value)

    @builtins.property
    @jsii.member(jsii_name="instanceTenancy")
    def instance_tenancy(self) -> typing.Optional[builtins.str]:
        '''The allowed tenancy of instances launched into the VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instanceTenancy"))

    @instance_tenancy.setter
    def instance_tenancy(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8d65d530ea680bb10f086d0fdbb0502a13ec6eeb42b29a710a3e6989798916ea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceTenancy", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4IpamPoolId")
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''The ID of an IPv4 IPAM pool you want to use for allocating this VPC's CIDR.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv4IpamPoolId"))

    @ipv4_ipam_pool_id.setter
    def ipv4_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4392bec5fe5fed25dd76667fbb47dc0e42ab059f7936a2b1a9e46b33b769665b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4NetmaskLength")
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv4 CIDR you want to allocate to this VPC from an Amazon VPC IP Address Manager (IPAM) pool.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv4NetmaskLength"))

    @ipv4_netmask_length.setter
    def ipv4_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__05091c2540acdcbf2cdc834f826aec0d6ece2e369ff306d4303712dbe07cdaf1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4NetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the VPC.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48b11f5a9856584abde78ea8179ea1e15a79daa88103bf860d8cfd4852cd9b39)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.implements(_IInspectable_c2943556)
class CfnVPCCidrBlock(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCCidrBlock",
):
    '''Associates a CIDR block with your VPC.

    You can optionally request an IPv6 CIDR block for the VPC. You can request an Amazon-provided IPv6 CIDR block from Amazon's pool of IPv6 addresses, or an IPv6 CIDR block from an IPv6 address pool that you provisioned through bring your own IP addresses (BYOIP).

    For more information, see `VPC CIDR blocks <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html>`_ in the *Amazon VPC User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html
    :cloudformationResource: AWS::EC2::VPCCidrBlock
    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        def associate_subnet_with_v6_cidr(self, vpc, count, subnet):
            cfn_subnet = subnet.node.default_child
            cfn_subnet.ipv6_cidr_block = Fn.select(count, Fn.cidr(Fn.select(0, vpc.vpc_ipv6_cidr_blocks), 256, (128 - 64).to_string()))
            cfn_subnet.assign_ipv6_address_on_creation = True
        
        # make an ipv6 cidr
        ipv6cidr = ec2.CfnVPCCidrBlock(self, "CIDR6",
            vpc_id=vpc.vpc_id,
            amazon_provided_ipv6_cidr_block=True
        )
        
        # connect the ipv6 cidr to all vpc subnets
        subnetcount = 0
        subnets = vpc.public_subnets.concat(vpc.private_subnets)
        for subnet in subnets:
            # Wait for the ipv6 cidr to complete
            subnet.node.add_dependency(ipv6cidr)
            associate_subnet_with_v6_cidr(vpc, subnetcount, subnet)
            subnetcount = subnetcount + 1
        
        cluster = eks.Cluster(self, "hello-eks",
            version=eks.KubernetesVersion.V1_29,
            vpc=vpc,
            ip_family=eks.IpFamily.IP_V6,
            vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        amazon_provided_ipv6_cidr_block: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        cidr_block: typing.Optional[builtins.str] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_pool: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC.
        :param amazon_provided_ipv6_cidr_block: Requests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC. You cannot specify the range of IPv6 addresses or the size of the CIDR block.
        :param cidr_block: An IPv4 CIDR block to associate with the VPC.
        :param ipv4_ipam_pool_id: Associate a CIDR allocated from an IPv4 IPAM pool to a VPC. For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv4_netmask_length: The netmask length of the IPv4 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_cidr_block: An IPv6 CIDR block from the IPv6 address pool. You must also specify ``Ipv6Pool`` in the request. To let Amazon choose the IPv6 CIDR block for you, omit this parameter.
        :param ipv6_ipam_pool_id: Associates a CIDR allocated from an IPv6 IPAM pool to a VPC. For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_netmask_length: The netmask length of the IPv6 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_pool: The ID of an IPv6 address pool from which to allocate the IPv6 CIDR block.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__183c6879cecf5e6ddd997bbb9856489efd89dd91a20b0a897e4a12a459346d37)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCCidrBlockProps(
            vpc_id=vpc_id,
            amazon_provided_ipv6_cidr_block=amazon_provided_ipv6_cidr_block,
            cidr_block=cidr_block,
            ipv4_ipam_pool_id=ipv4_ipam_pool_id,
            ipv4_netmask_length=ipv4_netmask_length,
            ipv6_cidr_block=ipv6_cidr_block,
            ipv6_ipam_pool_id=ipv6_ipam_pool_id,
            ipv6_netmask_length=ipv6_netmask_length,
            ipv6_pool=ipv6_pool,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__55e11c04fe82c2d36be04dccd85d599b2207e3c1f84f30fa597f5c0679365f56)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6deb753808a5dcb816815d58d46520df4de2a31856a0dd5fec1aa63dd12b8b5d)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''
        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1eb2368232a584720fe24adf42f2fea5d0dc555e4ca50f2e83c3181cce67df39)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="amazonProvidedIpv6CidrBlock")
    def amazon_provided_ipv6_cidr_block(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Requests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "amazonProvidedIpv6CidrBlock"))

    @amazon_provided_ipv6_cidr_block.setter
    def amazon_provided_ipv6_cidr_block(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67e064277194f0ee630157d4f67958b8590b71bb2baa9f6bd024bc4ba68b8194)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "amazonProvidedIpv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="cidrBlock")
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''An IPv4 CIDR block to associate with the VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrBlock"))

    @cidr_block.setter
    def cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fca66c2b1e9d0fbb7d3746ec42b0c68e63b54725b9fcc33e8f9332c1c8a5ffa7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "cidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4IpamPoolId")
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''Associate a CIDR allocated from an IPv4 IPAM pool to a VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv4IpamPoolId"))

    @ipv4_ipam_pool_id.setter
    def ipv4_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a8a10519bbe642c76098123b41f05c0e927d67d2e9cf96fcf1ca647e7f756d1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv4NetmaskLength")
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv4 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv4NetmaskLength"))

    @ipv4_netmask_length.setter
    def ipv4_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5fcd7e03b583fcf369c24b9623466fd52788b1fee99e653c567014f4f71383d8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv4NetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6CidrBlock")
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''An IPv6 CIDR block from the IPv6 address pool.

        You must also specify ``Ipv6Pool`` in the request.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6CidrBlock"))

    @ipv6_cidr_block.setter
    def ipv6_cidr_block(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2efd97c3af41c8a8c16797aaca56cbbacebc3fff0fc5ec71d75cd3d0c44642c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6CidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6IpamPoolId")
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''Associates a CIDR allocated from an IPv6 IPAM pool to a VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6IpamPoolId"))

    @ipv6_ipam_pool_id.setter
    def ipv6_ipam_pool_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__90a5a1f83f5bbe2892474aeba0dbaee518350d03fcd592eb44bce97ecc24b6b4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6IpamPoolId", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6NetmaskLength")
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv6 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "ipv6NetmaskLength"))

    @ipv6_netmask_length.setter
    def ipv6_netmask_length(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d003bf6babd2e3fda2c716a6c7e74ba83d0de8a16ce7bed075587c07683adcc0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6NetmaskLength", value)

    @builtins.property
    @jsii.member(jsii_name="ipv6Pool")
    def ipv6_pool(self) -> typing.Optional[builtins.str]:
        '''The ID of an IPv6 address pool from which to allocate the IPv6 CIDR block.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6Pool"))

    @ipv6_pool.setter
    def ipv6_pool(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e1971ac5759a7e790f834281baeac4f3a29bd93d7dd0b5b74f6f6500cfccd21)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ipv6Pool", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCCidrBlockProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc_id": "vpcId",
        "amazon_provided_ipv6_cidr_block": "amazonProvidedIpv6CidrBlock",
        "cidr_block": "cidrBlock",
        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
        "ipv4_netmask_length": "ipv4NetmaskLength",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "ipv6_ipam_pool_id": "ipv6IpamPoolId",
        "ipv6_netmask_length": "ipv6NetmaskLength",
        "ipv6_pool": "ipv6Pool",
    },
)
class CfnVPCCidrBlockProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        amazon_provided_ipv6_cidr_block: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        cidr_block: typing.Optional[builtins.str] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
        ipv6_pool: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCCidrBlock``.

        :param vpc_id: The ID of the VPC.
        :param amazon_provided_ipv6_cidr_block: Requests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC. You cannot specify the range of IPv6 addresses or the size of the CIDR block.
        :param cidr_block: An IPv4 CIDR block to associate with the VPC.
        :param ipv4_ipam_pool_id: Associate a CIDR allocated from an IPv4 IPAM pool to a VPC. For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv4_netmask_length: The netmask length of the IPv4 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_cidr_block: An IPv6 CIDR block from the IPv6 address pool. You must also specify ``Ipv6Pool`` in the request. To let Amazon choose the IPv6 CIDR block for you, omit this parameter.
        :param ipv6_ipam_pool_id: Associates a CIDR allocated from an IPv6 IPAM pool to a VPC. For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_netmask_length: The netmask length of the IPv6 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param ipv6_pool: The ID of an IPv6 address pool from which to allocate the IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html
        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            
            def associate_subnet_with_v6_cidr(self, vpc, count, subnet):
                cfn_subnet = subnet.node.default_child
                cfn_subnet.ipv6_cidr_block = Fn.select(count, Fn.cidr(Fn.select(0, vpc.vpc_ipv6_cidr_blocks), 256, (128 - 64).to_string()))
                cfn_subnet.assign_ipv6_address_on_creation = True
            
            # make an ipv6 cidr
            ipv6cidr = ec2.CfnVPCCidrBlock(self, "CIDR6",
                vpc_id=vpc.vpc_id,
                amazon_provided_ipv6_cidr_block=True
            )
            
            # connect the ipv6 cidr to all vpc subnets
            subnetcount = 0
            subnets = vpc.public_subnets.concat(vpc.private_subnets)
            for subnet in subnets:
                # Wait for the ipv6 cidr to complete
                subnet.node.add_dependency(ipv6cidr)
                associate_subnet_with_v6_cidr(vpc, subnetcount, subnet)
                subnetcount = subnetcount + 1
            
            cluster = eks.Cluster(self, "hello-eks",
                version=eks.KubernetesVersion.V1_29,
                vpc=vpc,
                ip_family=eks.IpFamily.IP_V6,
                vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__55248a04c0e8026131066b5c27e0e5fd8fa2cbce8f31b88e00a3080d92a0279e)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument amazon_provided_ipv6_cidr_block", value=amazon_provided_ipv6_cidr_block, expected_type=type_hints["amazon_provided_ipv6_cidr_block"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument ipv4_ipam_pool_id", value=ipv4_ipam_pool_id, expected_type=type_hints["ipv4_ipam_pool_id"])
            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument ipv6_ipam_pool_id", value=ipv6_ipam_pool_id, expected_type=type_hints["ipv6_ipam_pool_id"])
            check_type(argname="argument ipv6_netmask_length", value=ipv6_netmask_length, expected_type=type_hints["ipv6_netmask_length"])
            check_type(argname="argument ipv6_pool", value=ipv6_pool, expected_type=type_hints["ipv6_pool"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if amazon_provided_ipv6_cidr_block is not None:
            self._values["amazon_provided_ipv6_cidr_block"] = amazon_provided_ipv6_cidr_block
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if ipv4_ipam_pool_id is not None:
            self._values["ipv4_ipam_pool_id"] = ipv4_ipam_pool_id
        if ipv4_netmask_length is not None:
            self._values["ipv4_netmask_length"] = ipv4_netmask_length
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if ipv6_ipam_pool_id is not None:
            self._values["ipv6_ipam_pool_id"] = ipv6_ipam_pool_id
        if ipv6_netmask_length is not None:
            self._values["ipv6_netmask_length"] = ipv6_netmask_length
        if ipv6_pool is not None:
            self._values["ipv6_pool"] = ipv6_pool

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def amazon_provided_ipv6_cidr_block(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Requests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC.

        You cannot specify the range of IPv6 addresses or the size of the CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-amazonprovidedipv6cidrblock
        '''
        result = self._values.get("amazon_provided_ipv6_cidr_block")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''An IPv4 CIDR block to associate with the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-cidrblock
        '''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''Associate a CIDR allocated from an IPv4 IPAM pool to a VPC.

        For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv4ipampoolid
        '''
        result = self._values.get("ipv4_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv4 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool.

        For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv4netmasklength
        '''
        result = self._values.get("ipv4_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''An IPv6 CIDR block from the IPv6 address pool. You must also specify ``Ipv6Pool`` in the request.

        To let Amazon choose the IPv6 CIDR block for you, omit this parameter.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv6cidrblock
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''Associates a CIDR allocated from an IPv6 IPAM pool to a VPC.

        For more information about Amazon VPC IP Address Manager (IPAM), see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv6ipampoolid
        '''
        result = self._values.get("ipv6_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv6 CIDR you would like to associate from an Amazon VPC IP Address Manager (IPAM) pool.

        For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv6netmasklength
        '''
        result = self._values.get("ipv6_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_pool(self) -> typing.Optional[builtins.str]:
        '''The ID of an IPv6 address pool from which to allocate the IPv6 CIDR block.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpccidrblock.html#cfn-ec2-vpccidrblock-ipv6pool
        '''
        result = self._values.get("ipv6_pool")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCCidrBlockProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPCDHCPOptionsAssociation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCDHCPOptionsAssociation",
):
    '''Associates a set of DHCP options with a VPC, or associates no DHCP options with the VPC.

    After you associate the options with the VPC, any existing instances and all new instances that you launch in that VPC use the options. You don't need to restart or relaunch the instances. They automatically pick up the changes within a few hours, depending on how frequently the instance renews its DHCP lease. You can explicitly renew the lease using the operating system on the instance.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcdhcpoptionsassociation.html
    :cloudformationResource: AWS::EC2::VPCDHCPOptionsAssociation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCDHCPOptions_association = ec2.CfnVPCDHCPOptionsAssociation(self, "MyCfnVPCDHCPOptionsAssociation",
            dhcp_options_id="dhcpOptionsId",
            vpc_id="vpcId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        dhcp_options_id: builtins.str,
        vpc_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param dhcp_options_id: The ID of the DHCP options set, or ``default`` to associate no DHCP options with the VPC.
        :param vpc_id: The ID of the VPC.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b9bb034214f5dc77d48f0c0859b46782ac6d39c672cbdb5f28f61b41965eef4a)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCDHCPOptionsAssociationProps(
            dhcp_options_id=dhcp_options_id, vpc_id=vpc_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d3ff1830cb5525663a7a195e9d7674f4ede7abc671337ab6826874c27ff24255)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1575a3d3c0b16382fbd67aea32d49e0b4a40a67d295511829a1d82675e6f0b5b)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="dhcpOptionsId")
    def dhcp_options_id(self) -> builtins.str:
        '''The ID of the DHCP options set, or ``default`` to associate no DHCP options with the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "dhcpOptionsId"))

    @dhcp_options_id.setter
    def dhcp_options_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1707945c06f70798e93e27d60ab06bcd4ba19922e8976b629c925c917a0842ed)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "dhcpOptionsId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__91e8d4b49f9afbba3e84350c9a368e27d6df44ac5ad18319ebf6aba61a74d810)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCDHCPOptionsAssociationProps",
    jsii_struct_bases=[],
    name_mapping={"dhcp_options_id": "dhcpOptionsId", "vpc_id": "vpcId"},
)
class CfnVPCDHCPOptionsAssociationProps:
    def __init__(self, *, dhcp_options_id: builtins.str, vpc_id: builtins.str) -> None:
        '''Properties for defining a ``CfnVPCDHCPOptionsAssociation``.

        :param dhcp_options_id: The ID of the DHCP options set, or ``default`` to associate no DHCP options with the VPC.
        :param vpc_id: The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcdhcpoptionsassociation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCDHCPOptions_association_props = ec2.CfnVPCDHCPOptionsAssociationProps(
                dhcp_options_id="dhcpOptionsId",
                vpc_id="vpcId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d233a95be90ec03e2a21cfd188b456c080aca97fc6b8cdfa321e42b243810d4a)
            check_type(argname="argument dhcp_options_id", value=dhcp_options_id, expected_type=type_hints["dhcp_options_id"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "dhcp_options_id": dhcp_options_id,
            "vpc_id": vpc_id,
        }

    @builtins.property
    def dhcp_options_id(self) -> builtins.str:
        '''The ID of the DHCP options set, or ``default`` to associate no DHCP options with the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcdhcpoptionsassociation.html#cfn-ec2-vpcdhcpoptionsassociation-dhcpoptionsid
        '''
        result = self._values.get("dhcp_options_id")
        assert result is not None, "Required property 'dhcp_options_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcdhcpoptionsassociation.html#cfn-ec2-vpcdhcpoptionsassociation-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCDHCPOptionsAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPCEndpoint(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpoint",
):
    '''Specifies a VPC endpoint.

    A VPC endpoint provides a private connection between your VPC and an endpoint service. You can use an endpoint service provided by AWS , an AWS Marketplace Partner, or another AWS accounts in your organization. For more information, see the `AWS PrivateLink User Guide <https://docs.aws.amazon.com/vpc/latest/privatelink/>`_ .

    An endpoint of type ``Interface`` establishes connections between the subnets in your VPC and an AWS service , your own service, or a service hosted by another AWS account . With an interface VPC endpoint, you specify the subnets in which to create the endpoint and the security groups to associate with the endpoint network interfaces.

    An endpoint of type ``gateway`` serves as a target for a route in your route table for traffic destined for Amazon S3 or DynamoDB . You can specify an endpoint policy for the endpoint, which controls access to the service from your VPC. You can also specify the VPC route tables that use the endpoint. For more information about connectivity to Amazon S3 , see `Why can't I connect to an S3 bucket using a gateway VPC endpoint? <https://docs.aws.amazon.com/premiumsupport/knowledge-center/connect-s3-vpc-endpoint>`_

    An endpoint of type ``GatewayLoadBalancer`` provides private connectivity between your VPC and virtual appliances from a service provider.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html
    :cloudformationResource: AWS::EC2::VPCEndpoint
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # policy_document: Any
        
        cfn_vPCEndpoint = ec2.CfnVPCEndpoint(self, "MyCfnVPCEndpoint",
            service_name="serviceName",
            vpc_id="vpcId",
        
            # the properties below are optional
            policy_document=policy_document,
            private_dns_enabled=False,
            route_table_ids=["routeTableIds"],
            security_group_ids=["securityGroupIds"],
            subnet_ids=["subnetIds"],
            vpc_endpoint_type="vpcEndpointType"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        service_name: builtins.str,
        vpc_id: builtins.str,
        policy_document: typing.Any = None,
        private_dns_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        vpc_endpoint_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param service_name: The name of the endpoint service.
        :param vpc_id: The ID of the VPC.
        :param policy_document: An endpoint policy, which controls access to the service from the VPC. The default endpoint policy allows full access to the service. Endpoint policies are supported only for gateway and interface endpoints. For CloudFormation templates in YAML, you can provide the policy in JSON or YAML format. AWS CloudFormation converts YAML policies to JSON format before calling the API to create or modify the VPC endpoint.
        :param private_dns_enabled: Indicate whether to associate a private hosted zone with the specified VPC. The private hosted zone contains a record set for the default public DNS name for the service for the Region (for example, ``kinesis.us-east-1.amazonaws.com`` ), which resolves to the private IP addresses of the endpoint network interfaces in the VPC. This enables you to make requests to the default public DNS name for the service instead of the public DNS names that are automatically generated by the VPC endpoint service. To use a private hosted zone, you must set the following VPC attributes to ``true`` : ``enableDnsHostnames`` and ``enableDnsSupport`` . This property is supported only for interface endpoints. Default: ``false``
        :param route_table_ids: The IDs of the route tables. Routing is supported only for gateway endpoints.
        :param security_group_ids: The IDs of the security groups to associate with the endpoint network interfaces. If this parameter is not specified, we use the default security group for the VPC. Security groups are supported only for interface endpoints.
        :param subnet_ids: The IDs of the subnets in which to create endpoint network interfaces. You must specify this property for an interface endpoint or a Gateway Load Balancer endpoint. You can't specify this property for a gateway endpoint. For a Gateway Load Balancer endpoint, you can specify only one subnet.
        :param vpc_endpoint_type: The type of endpoint. Default: Gateway
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a16478d34754d994e7b5d75d1e427abd720d7df3e6b3c870e3e83c927817da50)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCEndpointProps(
            service_name=service_name,
            vpc_id=vpc_id,
            policy_document=policy_document,
            private_dns_enabled=private_dns_enabled,
            route_table_ids=route_table_ids,
            security_group_ids=security_group_ids,
            subnet_ids=subnet_ids,
            vpc_endpoint_type=vpc_endpoint_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c54b99dd0fd377d6fc52123dfe3ad824e1fb2e886fde2b0c922a6483aff148a)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8180577e06d5f40db7bfe860861e761a322315b93022f1003a828f6a78b29f79)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTimestamp")
    def attr_creation_timestamp(self) -> builtins.str:
        '''The date and time the VPC endpoint was created.

        For example: ``Fri Sep 28 23:34:36 UTC 2018.``

        :cloudformationAttribute: CreationTimestamp
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTimestamp"))

    @builtins.property
    @jsii.member(jsii_name="attrDnsEntries")
    def attr_dns_entries(self) -> typing.List[builtins.str]:
        '''(Interface endpoints) The DNS entries for the endpoint.

        Each entry is a combination of the hosted zone ID and the DNS name. The entries are ordered as follows: regional public DNS, zonal public DNS, private DNS, and wildcard DNS. This order is not enforced for AWS Marketplace services.

        The following is an example. In the first entry, the hosted zone ID is Z1HUB23UULQXV and the DNS name is vpce-01abc23456de78f9g-12abccd3.ec2.us-east-1.vpce.amazonaws.com.

        ["Z1HUB23UULQXV:vpce-01abc23456de78f9g-12abccd3.ec2.us-east-1.vpce.amazonaws.com", "Z1HUB23UULQXV:vpce-01abc23456de78f9g-12abccd3-us-east-1a.ec2.us-east-1.vpce.amazonaws.com", "Z1C12344VYDITB0:ec2.us-east-1.amazonaws.com"]

        If you update the ``PrivateDnsEnabled`` or ``SubnetIds`` properties, the DNS entries in the list will change.

        :cloudformationAttribute: DnsEntries
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrDnsEntries"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the VPC endpoint.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="attrNetworkInterfaceIds")
    def attr_network_interface_ids(self) -> typing.List[builtins.str]:
        '''(Interface endpoints) The network interface IDs.

        If you update the ``PrivateDnsEnabled`` or ``SubnetIds`` properties, the items in this list might change.

        :cloudformationAttribute: NetworkInterfaceIds
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrNetworkInterfaceIds"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="serviceName")
    def service_name(self) -> builtins.str:
        '''The name of the endpoint service.'''
        return typing.cast(builtins.str, jsii.get(self, "serviceName"))

    @service_name.setter
    def service_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2090beb1c51f8f71e8d917867bb4a45a0f3f15917f6cca0b5e935b108f8f0d2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "serviceName", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb23b7f52de7db6e9a625fa8454752268536cb8ff8ba9c44811e4eb3a0387370)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="policyDocument")
    def policy_document(self) -> typing.Any:
        '''An endpoint policy, which controls access to the service from the VPC.'''
        return typing.cast(typing.Any, jsii.get(self, "policyDocument"))

    @policy_document.setter
    def policy_document(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fef1f643fb4b202b92a09208369c8ab1fde9ddab70fbe2ec7846f4fcd21d6503)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyDocument", value)

    @builtins.property
    @jsii.member(jsii_name="privateDnsEnabled")
    def private_dns_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicate whether to associate a private hosted zone with the specified VPC.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "privateDnsEnabled"))

    @private_dns_enabled.setter
    def private_dns_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4dbca35e4914255e0279b1d61059956804d0f7250234053b0ee76a6384198570)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "privateDnsEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="routeTableIds")
    def route_table_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the route tables.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "routeTableIds"))

    @route_table_ids.setter
    def route_table_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f91ab410767d141e4748e5e96f72e9a5ccd579262fc325deb4f474e64b17369a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "routeTableIds", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIds")
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups to associate with the endpoint network interfaces.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroupIds"))

    @security_group_ids.setter
    def security_group_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ab2dcbb20cd327f7a249c214f6cfc93f9e023fea8764cdb0dba2461b164c533d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIds", value)

    @builtins.property
    @jsii.member(jsii_name="subnetIds")
    def subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the subnets in which to create endpoint network interfaces.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "subnetIds"))

    @subnet_ids.setter
    def subnet_ids(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b83f77b13bf225d451aa245360aebfaece0685d635a9b435d657b957d2d8bdc0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subnetIds", value)

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointType")
    def vpc_endpoint_type(self) -> typing.Optional[builtins.str]:
        '''The type of endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcEndpointType"))

    @vpc_endpoint_type.setter
    def vpc_endpoint_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8718b471ff8e08b446d204932a62ced5c20dc254a0eb7a3d246a776fcd8f0e83)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcEndpointType", value)


@jsii.implements(_IInspectable_c2943556)
class CfnVPCEndpointConnectionNotification(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointConnectionNotification",
):
    '''Specifies a connection notification for a VPC endpoint or VPC endpoint service.

    A connection notification notifies you of specific endpoint events. You must create an SNS topic to receive notifications. For more information, see `Create a Topic <https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html>`_ in the *Amazon Simple Notification Service Developer Guide* .

    You can create a connection notification for interface endpoints only.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html
    :cloudformationResource: AWS::EC2::VPCEndpointConnectionNotification
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCEndpoint_connection_notification = ec2.CfnVPCEndpointConnectionNotification(self, "MyCfnVPCEndpointConnectionNotification",
            connection_events=["connectionEvents"],
            connection_notification_arn="connectionNotificationArn",
        
            # the properties below are optional
            service_id="serviceId",
            vpc_endpoint_id="vpcEndpointId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        connection_events: typing.Sequence[builtins.str],
        connection_notification_arn: builtins.str,
        service_id: typing.Optional[builtins.str] = None,
        vpc_endpoint_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param connection_events: The endpoint events for which to receive notifications. Valid values are ``Accept`` , ``Connect`` , ``Delete`` , and ``Reject`` .
        :param connection_notification_arn: The ARN of the SNS topic for the notifications.
        :param service_id: The ID of the endpoint service.
        :param vpc_endpoint_id: The ID of the endpoint.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28ca470645ae7106b593e02924e610dbf279c08694ac6f66651c214c74d412de)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCEndpointConnectionNotificationProps(
            connection_events=connection_events,
            connection_notification_arn=connection_notification_arn,
            service_id=service_id,
            vpc_endpoint_id=vpc_endpoint_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea81fa4c28a28130c40f42ef988e07f5a933e12360aec4c4ce8906f11408be8e)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd5babf517110e51ba6c2026a81d423f167d3ff443224ecb8ae9157591c6fc94)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrVpcEndpointConnectionNotificationId")
    def attr_vpc_endpoint_connection_notification_id(self) -> builtins.str:
        '''The ID of the notification.

        :cloudformationAttribute: VPCEndpointConnectionNotificationId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpcEndpointConnectionNotificationId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="connectionEvents")
    def connection_events(self) -> typing.List[builtins.str]:
        '''The endpoint events for which to receive notifications.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "connectionEvents"))

    @connection_events.setter
    def connection_events(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__461502328f1915c382064a9f97e8339f106d85ad2e0bc2f2d6941c39fd0ebd29)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connectionEvents", value)

    @builtins.property
    @jsii.member(jsii_name="connectionNotificationArn")
    def connection_notification_arn(self) -> builtins.str:
        '''The ARN of the SNS topic for the notifications.'''
        return typing.cast(builtins.str, jsii.get(self, "connectionNotificationArn"))

    @connection_notification_arn.setter
    def connection_notification_arn(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca5d3ce920eb5a5d00fec3e569160090961a27d8388605e0da686c9ec9967d80)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "connectionNotificationArn", value)

    @builtins.property
    @jsii.member(jsii_name="serviceId")
    def service_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the endpoint service.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "serviceId"))

    @service_id.setter
    def service_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__854075224b2a1c5aaee62fd32ffce65442a53f3976b3271f37e670e2c26a8352)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "serviceId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpcEndpointId"))

    @vpc_endpoint_id.setter
    def vpc_endpoint_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6c4b48cfc16ca27f30c5478637f260bb601cdda20c27aa02b58ebb642f57eeb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcEndpointId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointConnectionNotificationProps",
    jsii_struct_bases=[],
    name_mapping={
        "connection_events": "connectionEvents",
        "connection_notification_arn": "connectionNotificationArn",
        "service_id": "serviceId",
        "vpc_endpoint_id": "vpcEndpointId",
    },
)
class CfnVPCEndpointConnectionNotificationProps:
    def __init__(
        self,
        *,
        connection_events: typing.Sequence[builtins.str],
        connection_notification_arn: builtins.str,
        service_id: typing.Optional[builtins.str] = None,
        vpc_endpoint_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCEndpointConnectionNotification``.

        :param connection_events: The endpoint events for which to receive notifications. Valid values are ``Accept`` , ``Connect`` , ``Delete`` , and ``Reject`` .
        :param connection_notification_arn: The ARN of the SNS topic for the notifications.
        :param service_id: The ID of the endpoint service.
        :param vpc_endpoint_id: The ID of the endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCEndpoint_connection_notification_props = ec2.CfnVPCEndpointConnectionNotificationProps(
                connection_events=["connectionEvents"],
                connection_notification_arn="connectionNotificationArn",
            
                # the properties below are optional
                service_id="serviceId",
                vpc_endpoint_id="vpcEndpointId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e41c3ca58468397b88d0fe9b9af25af62cccc7a408eadc3db2286a9f27a7fdff)
            check_type(argname="argument connection_events", value=connection_events, expected_type=type_hints["connection_events"])
            check_type(argname="argument connection_notification_arn", value=connection_notification_arn, expected_type=type_hints["connection_notification_arn"])
            check_type(argname="argument service_id", value=service_id, expected_type=type_hints["service_id"])
            check_type(argname="argument vpc_endpoint_id", value=vpc_endpoint_id, expected_type=type_hints["vpc_endpoint_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "connection_events": connection_events,
            "connection_notification_arn": connection_notification_arn,
        }
        if service_id is not None:
            self._values["service_id"] = service_id
        if vpc_endpoint_id is not None:
            self._values["vpc_endpoint_id"] = vpc_endpoint_id

    @builtins.property
    def connection_events(self) -> typing.List[builtins.str]:
        '''The endpoint events for which to receive notifications.

        Valid values are ``Accept`` , ``Connect`` , ``Delete`` , and ``Reject`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html#cfn-ec2-vpcendpointconnectionnotification-connectionevents
        '''
        result = self._values.get("connection_events")
        assert result is not None, "Required property 'connection_events' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def connection_notification_arn(self) -> builtins.str:
        '''The ARN of the SNS topic for the notifications.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html#cfn-ec2-vpcendpointconnectionnotification-connectionnotificationarn
        '''
        result = self._values.get("connection_notification_arn")
        assert result is not None, "Required property 'connection_notification_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def service_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the endpoint service.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html#cfn-ec2-vpcendpointconnectionnotification-serviceid
        '''
        result = self._values.get("service_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_endpoint_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointconnectionnotification.html#cfn-ec2-vpcendpointconnectionnotification-vpcendpointid
        '''
        result = self._values.get("vpc_endpoint_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCEndpointConnectionNotificationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointProps",
    jsii_struct_bases=[],
    name_mapping={
        "service_name": "serviceName",
        "vpc_id": "vpcId",
        "policy_document": "policyDocument",
        "private_dns_enabled": "privateDnsEnabled",
        "route_table_ids": "routeTableIds",
        "security_group_ids": "securityGroupIds",
        "subnet_ids": "subnetIds",
        "vpc_endpoint_type": "vpcEndpointType",
    },
)
class CfnVPCEndpointProps:
    def __init__(
        self,
        *,
        service_name: builtins.str,
        vpc_id: builtins.str,
        policy_document: typing.Any = None,
        private_dns_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        vpc_endpoint_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCEndpoint``.

        :param service_name: The name of the endpoint service.
        :param vpc_id: The ID of the VPC.
        :param policy_document: An endpoint policy, which controls access to the service from the VPC. The default endpoint policy allows full access to the service. Endpoint policies are supported only for gateway and interface endpoints. For CloudFormation templates in YAML, you can provide the policy in JSON or YAML format. AWS CloudFormation converts YAML policies to JSON format before calling the API to create or modify the VPC endpoint.
        :param private_dns_enabled: Indicate whether to associate a private hosted zone with the specified VPC. The private hosted zone contains a record set for the default public DNS name for the service for the Region (for example, ``kinesis.us-east-1.amazonaws.com`` ), which resolves to the private IP addresses of the endpoint network interfaces in the VPC. This enables you to make requests to the default public DNS name for the service instead of the public DNS names that are automatically generated by the VPC endpoint service. To use a private hosted zone, you must set the following VPC attributes to ``true`` : ``enableDnsHostnames`` and ``enableDnsSupport`` . This property is supported only for interface endpoints. Default: ``false``
        :param route_table_ids: The IDs of the route tables. Routing is supported only for gateway endpoints.
        :param security_group_ids: The IDs of the security groups to associate with the endpoint network interfaces. If this parameter is not specified, we use the default security group for the VPC. Security groups are supported only for interface endpoints.
        :param subnet_ids: The IDs of the subnets in which to create endpoint network interfaces. You must specify this property for an interface endpoint or a Gateway Load Balancer endpoint. You can't specify this property for a gateway endpoint. For a Gateway Load Balancer endpoint, you can specify only one subnet.
        :param vpc_endpoint_type: The type of endpoint. Default: Gateway

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # policy_document: Any
            
            cfn_vPCEndpoint_props = ec2.CfnVPCEndpointProps(
                service_name="serviceName",
                vpc_id="vpcId",
            
                # the properties below are optional
                policy_document=policy_document,
                private_dns_enabled=False,
                route_table_ids=["routeTableIds"],
                security_group_ids=["securityGroupIds"],
                subnet_ids=["subnetIds"],
                vpc_endpoint_type="vpcEndpointType"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34ba69df521981275d9321266877bb15ffeaff485197a94710ae57c73b0cd2f1)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument policy_document", value=policy_document, expected_type=type_hints["policy_document"])
            check_type(argname="argument private_dns_enabled", value=private_dns_enabled, expected_type=type_hints["private_dns_enabled"])
            check_type(argname="argument route_table_ids", value=route_table_ids, expected_type=type_hints["route_table_ids"])
            check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
            check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
            check_type(argname="argument vpc_endpoint_type", value=vpc_endpoint_type, expected_type=type_hints["vpc_endpoint_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service_name": service_name,
            "vpc_id": vpc_id,
        }
        if policy_document is not None:
            self._values["policy_document"] = policy_document
        if private_dns_enabled is not None:
            self._values["private_dns_enabled"] = private_dns_enabled
        if route_table_ids is not None:
            self._values["route_table_ids"] = route_table_ids
        if security_group_ids is not None:
            self._values["security_group_ids"] = security_group_ids
        if subnet_ids is not None:
            self._values["subnet_ids"] = subnet_ids
        if vpc_endpoint_type is not None:
            self._values["vpc_endpoint_type"] = vpc_endpoint_type

    @builtins.property
    def service_name(self) -> builtins.str:
        '''The name of the endpoint service.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-servicename
        '''
        result = self._values.get("service_name")
        assert result is not None, "Required property 'service_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def policy_document(self) -> typing.Any:
        '''An endpoint policy, which controls access to the service from the VPC.

        The default endpoint policy allows full access to the service. Endpoint policies are supported only for gateway and interface endpoints.

        For CloudFormation templates in YAML, you can provide the policy in JSON or YAML format. AWS CloudFormation converts YAML policies to JSON format before calling the API to create or modify the VPC endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-policydocument
        '''
        result = self._values.get("policy_document")
        return typing.cast(typing.Any, result)

    @builtins.property
    def private_dns_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicate whether to associate a private hosted zone with the specified VPC.

        The private hosted zone contains a record set for the default public DNS name for the service for the Region (for example, ``kinesis.us-east-1.amazonaws.com`` ), which resolves to the private IP addresses of the endpoint network interfaces in the VPC. This enables you to make requests to the default public DNS name for the service instead of the public DNS names that are automatically generated by the VPC endpoint service.

        To use a private hosted zone, you must set the following VPC attributes to ``true`` : ``enableDnsHostnames`` and ``enableDnsSupport`` .

        This property is supported only for interface endpoints.

        Default: ``false``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-privatednsenabled
        '''
        result = self._values.get("private_dns_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def route_table_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the route tables.

        Routing is supported only for gateway endpoints.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-routetableids
        '''
        result = self._values.get("route_table_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups to associate with the endpoint network interfaces.

        If this parameter is not specified, we use the default security group for the VPC. Security groups are supported only for interface endpoints.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-securitygroupids
        '''
        result = self._values.get("security_group_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the subnets in which to create endpoint network interfaces.

        You must specify this property for an interface endpoint or a Gateway Load Balancer endpoint. You can't specify this property for a gateway endpoint. For a Gateway Load Balancer endpoint, you can specify only one subnet.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-subnetids
        '''
        result = self._values.get("subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def vpc_endpoint_type(self) -> typing.Optional[builtins.str]:
        '''The type of endpoint.

        Default: Gateway

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html#cfn-ec2-vpcendpoint-vpcendpointtype
        '''
        result = self._values.get("vpc_endpoint_type")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPCEndpointService(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointService",
):
    '''Creates a VPC endpoint service configuration to which service consumers ( AWS accounts, users, and IAM roles) can connect.

    To create an endpoint service configuration, you must first create one of the following for your service:

    - A `Network Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html>`_ . Service consumers connect to your service using an interface endpoint.
    - A `Gateway Load Balancer <https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/introduction.html>`_ . Service consumers connect to your service using a Gateway Load Balancer endpoint.

    For more information, see the `AWS PrivateLink User Guide <https://docs.aws.amazon.com/vpc/latest/privatelink/>`_ .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html
    :cloudformationResource: AWS::EC2::VPCEndpointService
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCEndpoint_service = ec2.CfnVPCEndpointService(self, "MyCfnVPCEndpointService",
            acceptance_required=False,
            contributor_insights_enabled=False,
            gateway_load_balancer_arns=["gatewayLoadBalancerArns"],
            network_load_balancer_arns=["networkLoadBalancerArns"],
            payer_responsibility="payerResponsibility"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        acceptance_required: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        contributor_insights_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        gateway_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        network_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        payer_responsibility: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param acceptance_required: Indicates whether requests from service consumers to create an endpoint to your service must be accepted.
        :param contributor_insights_enabled: Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink .
        :param gateway_load_balancer_arns: The Amazon Resource Names (ARNs) of the Gateway Load Balancers.
        :param network_load_balancer_arns: The Amazon Resource Names (ARNs) of the Network Load Balancers.
        :param payer_responsibility: The entity that is responsible for the endpoint costs. The default is the endpoint owner. If you set the payer responsibility to the service owner, you cannot set it back to the endpoint owner.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bd65bb2d0beb1d62ef8b72a33a352ac48e00600bc2b025bdec06b82cf7cf57ee)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCEndpointServiceProps(
            acceptance_required=acceptance_required,
            contributor_insights_enabled=contributor_insights_enabled,
            gateway_load_balancer_arns=gateway_load_balancer_arns,
            network_load_balancer_arns=network_load_balancer_arns,
            payer_responsibility=payer_responsibility,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__957d0b13087a5a1c7afd830c8d67d8a66dda673f60c930be5db2f6796e21edf4)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ade08a9cff0bfa7cbf329c1fe21275bce925552ca1507ee915e5ed307657556)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrServiceId")
    def attr_service_id(self) -> builtins.str:
        '''The ID of the endpoint service.

        :cloudformationAttribute: ServiceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrServiceId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="acceptanceRequired")
    def acceptance_required(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether requests from service consumers to create an endpoint to your service must be accepted.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "acceptanceRequired"))

    @acceptance_required.setter
    def acceptance_required(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f24d84605dd93d128eab36463b95fc34a65ac34595988f288ba091969d8c3e48)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "acceptanceRequired", value)

    @builtins.property
    @jsii.member(jsii_name="contributorInsightsEnabled")
    def contributor_insights_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink .'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "contributorInsightsEnabled"))

    @contributor_insights_enabled.setter
    def contributor_insights_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a38f79e9d58e9d5ccde278abb390c63a399ad8469ef4c429447f8e973e86b1db)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "contributorInsightsEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="gatewayLoadBalancerArns")
    def gateway_load_balancer_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARNs) of the Gateway Load Balancers.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "gatewayLoadBalancerArns"))

    @gateway_load_balancer_arns.setter
    def gateway_load_balancer_arns(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__92370ad93c8a0a0919c9746f7cdec6b56b2b1b55f53f9d2cbc0669e5b6091201)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "gatewayLoadBalancerArns", value)

    @builtins.property
    @jsii.member(jsii_name="networkLoadBalancerArns")
    def network_load_balancer_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARNs) of the Network Load Balancers.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "networkLoadBalancerArns"))

    @network_load_balancer_arns.setter
    def network_load_balancer_arns(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__93061701b7bc363aae54280ccf83f94479c38567908d2c51597ad1ee58387d4d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkLoadBalancerArns", value)

    @builtins.property
    @jsii.member(jsii_name="payerResponsibility")
    def payer_responsibility(self) -> typing.Optional[builtins.str]:
        '''The entity that is responsible for the endpoint costs.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "payerResponsibility"))

    @payer_responsibility.setter
    def payer_responsibility(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2babfa96e86ea450f85f7e83cc11905d68dc09b226c3e578bfcba308572f24b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "payerResponsibility", value)


@jsii.implements(_IInspectable_c2943556)
class CfnVPCEndpointServicePermissions(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointServicePermissions",
):
    '''Grant or revoke permissions for service consumers (users, IAM roles, and AWS accounts) to connect to a VPC endpoint service.

    If you grant permissions to all principals, the service is public. Any users who know the name of a public service can send a request to attach an endpoint. If the service does not require manual approval, attachments are automatically approved.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservicepermissions.html
    :cloudformationResource: AWS::EC2::VPCEndpointServicePermissions
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCEndpoint_service_permissions = ec2.CfnVPCEndpointServicePermissions(self, "MyCfnVPCEndpointServicePermissions",
            service_id="serviceId",
        
            # the properties below are optional
            allowed_principals=["allowedPrincipals"]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        service_id: builtins.str,
        allowed_principals: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param service_id: The ID of the service.
        :param allowed_principals: The Amazon Resource Names (ARN) of one or more principals (for example, users, IAM roles, and AWS accounts ). Permissions are granted to the principals in this list. To grant permissions to all principals, specify an asterisk (*). Permissions are revoked for principals not in this list. If the list is empty, then all permissions are revoked.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9f265c29703b637af4ed1222cca0cdcd5ff13a4888b2a6771b0476aa3c6edb0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCEndpointServicePermissionsProps(
            service_id=service_id, allowed_principals=allowed_principals
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4af6194d274e73e0d84c9e28ad5f3f905ffa6eb3074c07ecee54c53724dc9e47)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a7d0bdf0df2c60d10ef1d8a9cb9da9138c3f9cc7ab38f59acb47fcf89c470ea)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="serviceId")
    def service_id(self) -> builtins.str:
        '''The ID of the service.'''
        return typing.cast(builtins.str, jsii.get(self, "serviceId"))

    @service_id.setter
    def service_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cab72c441e664d891c2b30162073f27b3e88386b86be41a3880bcdcab431cefb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "serviceId", value)

    @builtins.property
    @jsii.member(jsii_name="allowedPrincipals")
    def allowed_principals(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARN) of one or more principals (for example, users, IAM roles, and AWS accounts ).'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "allowedPrincipals"))

    @allowed_principals.setter
    def allowed_principals(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ef9e1e30adb2a660166f4bf6fc1fca3b8169d82d5fac79c57597759e90d51b55)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "allowedPrincipals", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointServicePermissionsProps",
    jsii_struct_bases=[],
    name_mapping={
        "service_id": "serviceId",
        "allowed_principals": "allowedPrincipals",
    },
)
class CfnVPCEndpointServicePermissionsProps:
    def __init__(
        self,
        *,
        service_id: builtins.str,
        allowed_principals: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCEndpointServicePermissions``.

        :param service_id: The ID of the service.
        :param allowed_principals: The Amazon Resource Names (ARN) of one or more principals (for example, users, IAM roles, and AWS accounts ). Permissions are granted to the principals in this list. To grant permissions to all principals, specify an asterisk (*). Permissions are revoked for principals not in this list. If the list is empty, then all permissions are revoked.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservicepermissions.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCEndpoint_service_permissions_props = ec2.CfnVPCEndpointServicePermissionsProps(
                service_id="serviceId",
            
                # the properties below are optional
                allowed_principals=["allowedPrincipals"]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6fa6b05f468834197f8ac5ad6fead69a294ceac2af65d381e83ad97a1f2cead8)
            check_type(argname="argument service_id", value=service_id, expected_type=type_hints["service_id"])
            check_type(argname="argument allowed_principals", value=allowed_principals, expected_type=type_hints["allowed_principals"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service_id": service_id,
        }
        if allowed_principals is not None:
            self._values["allowed_principals"] = allowed_principals

    @builtins.property
    def service_id(self) -> builtins.str:
        '''The ID of the service.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservicepermissions.html#cfn-ec2-vpcendpointservicepermissions-serviceid
        '''
        result = self._values.get("service_id")
        assert result is not None, "Required property 'service_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def allowed_principals(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARN) of one or more principals (for example, users, IAM roles, and AWS accounts ).

        Permissions are granted to the principals in this list. To grant permissions to all principals, specify an asterisk (*). Permissions are revoked for principals not in this list. If the list is empty, then all permissions are revoked.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservicepermissions.html#cfn-ec2-vpcendpointservicepermissions-allowedprincipals
        '''
        result = self._values.get("allowed_principals")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCEndpointServicePermissionsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCEndpointServiceProps",
    jsii_struct_bases=[],
    name_mapping={
        "acceptance_required": "acceptanceRequired",
        "contributor_insights_enabled": "contributorInsightsEnabled",
        "gateway_load_balancer_arns": "gatewayLoadBalancerArns",
        "network_load_balancer_arns": "networkLoadBalancerArns",
        "payer_responsibility": "payerResponsibility",
    },
)
class CfnVPCEndpointServiceProps:
    def __init__(
        self,
        *,
        acceptance_required: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        contributor_insights_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        gateway_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        network_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
        payer_responsibility: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCEndpointService``.

        :param acceptance_required: Indicates whether requests from service consumers to create an endpoint to your service must be accepted.
        :param contributor_insights_enabled: Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink .
        :param gateway_load_balancer_arns: The Amazon Resource Names (ARNs) of the Gateway Load Balancers.
        :param network_load_balancer_arns: The Amazon Resource Names (ARNs) of the Network Load Balancers.
        :param payer_responsibility: The entity that is responsible for the endpoint costs. The default is the endpoint owner. If you set the payer responsibility to the service owner, you cannot set it back to the endpoint owner.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCEndpoint_service_props = ec2.CfnVPCEndpointServiceProps(
                acceptance_required=False,
                contributor_insights_enabled=False,
                gateway_load_balancer_arns=["gatewayLoadBalancerArns"],
                network_load_balancer_arns=["networkLoadBalancerArns"],
                payer_responsibility="payerResponsibility"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0924bdc7dd965ab8320d62e573fa88bcec434cb586b2ba9e4f291616938c2120)
            check_type(argname="argument acceptance_required", value=acceptance_required, expected_type=type_hints["acceptance_required"])
            check_type(argname="argument contributor_insights_enabled", value=contributor_insights_enabled, expected_type=type_hints["contributor_insights_enabled"])
            check_type(argname="argument gateway_load_balancer_arns", value=gateway_load_balancer_arns, expected_type=type_hints["gateway_load_balancer_arns"])
            check_type(argname="argument network_load_balancer_arns", value=network_load_balancer_arns, expected_type=type_hints["network_load_balancer_arns"])
            check_type(argname="argument payer_responsibility", value=payer_responsibility, expected_type=type_hints["payer_responsibility"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if acceptance_required is not None:
            self._values["acceptance_required"] = acceptance_required
        if contributor_insights_enabled is not None:
            self._values["contributor_insights_enabled"] = contributor_insights_enabled
        if gateway_load_balancer_arns is not None:
            self._values["gateway_load_balancer_arns"] = gateway_load_balancer_arns
        if network_load_balancer_arns is not None:
            self._values["network_load_balancer_arns"] = network_load_balancer_arns
        if payer_responsibility is not None:
            self._values["payer_responsibility"] = payer_responsibility

    @builtins.property
    def acceptance_required(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether requests from service consumers to create an endpoint to your service must be accepted.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html#cfn-ec2-vpcendpointservice-acceptancerequired
        '''
        result = self._values.get("acceptance_required")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def contributor_insights_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html#cfn-ec2-vpcendpointservice-contributorinsightsenabled
        '''
        result = self._values.get("contributor_insights_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def gateway_load_balancer_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARNs) of the Gateway Load Balancers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html#cfn-ec2-vpcendpointservice-gatewayloadbalancerarns
        '''
        result = self._values.get("gateway_load_balancer_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def network_load_balancer_arns(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The Amazon Resource Names (ARNs) of the Network Load Balancers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html#cfn-ec2-vpcendpointservice-networkloadbalancerarns
        '''
        result = self._values.get("network_load_balancer_arns")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def payer_responsibility(self) -> typing.Optional[builtins.str]:
        '''The entity that is responsible for the endpoint costs.

        The default is the endpoint owner. If you set the payer responsibility to the service owner, you cannot set it back to the endpoint owner.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpointservice.html#cfn-ec2-vpcendpointservice-payerresponsibility
        '''
        result = self._values.get("payer_responsibility")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCEndpointServiceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPCGatewayAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCGatewayAttachment",
):
    '''Attaches an internet gateway, or a virtual private gateway to a VPC, enabling connectivity between the internet and the VPC.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcgatewayattachment.html
    :cloudformationResource: AWS::EC2::VPCGatewayAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCGateway_attachment = ec2.CfnVPCGatewayAttachment(self, "MyCfnVPCGatewayAttachment",
            vpc_id="vpcId",
        
            # the properties below are optional
            internet_gateway_id="internetGatewayId",
            vpn_gateway_id="vpnGatewayId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_id: builtins.str,
        internet_gateway_id: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param vpc_id: The ID of the VPC.
        :param internet_gateway_id: The ID of the internet gateway. You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_gateway_id: The ID of the virtual private gateway. You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd545e7e637e4c1fe8133e31ecb56fe8e86ad6380825864b2456a3974ec7d612)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCGatewayAttachmentProps(
            vpc_id=vpc_id,
            internet_gateway_id=internet_gateway_id,
            vpn_gateway_id=vpn_gateway_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e8c1b051e6949f327f5f887d473e4ed8fa7ab3d78dcbbcdd368720a3c3bdcdbb)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19cdd8410853a775601a72c0c56d426086a8c740a41193ffd27460252888cac7)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrAttachmentType")
    def attr_attachment_type(self) -> builtins.str:
        '''Used to identify if this resource is an Internet Gateway or Vpn Gateway Attachment.

        :cloudformationAttribute: AttachmentType
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrAttachmentType"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dca7e25f2ecac14ca4d5d0f2d4e239a679ed34b28c7d68b120c424ee4b6ea61a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="internetGatewayId")
    def internet_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the internet gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "internetGatewayId"))

    @internet_gateway_id.setter
    def internet_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02529bf6feaf9b8eb6e764e95564b1545a5df8516772795cada582a51faa964f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "internetGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual private gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpnGatewayId"))

    @vpn_gateway_id.setter
    def vpn_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dbbf47daf665dafbdfd3b3091635738948b3269fd92d6b666d2553accf67aaeb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnGatewayId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCGatewayAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc_id": "vpcId",
        "internet_gateway_id": "internetGatewayId",
        "vpn_gateway_id": "vpnGatewayId",
    },
)
class CfnVPCGatewayAttachmentProps:
    def __init__(
        self,
        *,
        vpc_id: builtins.str,
        internet_gateway_id: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCGatewayAttachment``.

        :param vpc_id: The ID of the VPC.
        :param internet_gateway_id: The ID of the internet gateway. You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_gateway_id: The ID of the virtual private gateway. You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcgatewayattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCGateway_attachment_props = ec2.CfnVPCGatewayAttachmentProps(
                vpc_id="vpcId",
            
                # the properties below are optional
                internet_gateway_id="internetGatewayId",
                vpn_gateway_id="vpnGatewayId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cecf6c938749e886ce2b690feb4051e950c34a1abd4598f60184e9796a4fc95)
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument internet_gateway_id", value=internet_gateway_id, expected_type=type_hints["internet_gateway_id"])
            check_type(argname="argument vpn_gateway_id", value=vpn_gateway_id, expected_type=type_hints["vpn_gateway_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_id": vpc_id,
        }
        if internet_gateway_id is not None:
            self._values["internet_gateway_id"] = internet_gateway_id
        if vpn_gateway_id is not None:
            self._values["vpn_gateway_id"] = vpn_gateway_id

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcgatewayattachment.html#cfn-ec2-vpcgatewayattachment-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def internet_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the internet gateway.

        You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcgatewayattachment.html#cfn-ec2-vpcgatewayattachment-internetgatewayid
        '''
        result = self._values.get("internet_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual private gateway.

        You must specify either ``InternetGatewayId`` or ``VpnGatewayId`` , but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcgatewayattachment.html#cfn-ec2-vpcgatewayattachment-vpngatewayid
        '''
        result = self._values.get("vpn_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCGatewayAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVPCPeeringConnection(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCPeeringConnection",
):
    '''Requests a VPC peering connection between two VPCs: a requester VPC that you own and an accepter VPC with which to create the connection.

    The accepter VPC can belong to a different AWS account and can be in a different Region than the requester VPC.

    The requester VPC and accepter VPC cannot have overlapping CIDR blocks. If you create a VPC peering connection request between VPCs with overlapping CIDR blocks, the VPC peering connection has a status of ``failed`` .

    If the VPCs belong to different accounts, the acceptor account must have a role that allows the requester account to accept the VPC peering connection. For more information, see `Walkthough: Peer with a VPC in another AWS account <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/peer-with-vpc-in-another-account.html>`_ .

    If the requester and acceptor VPCs are in the same account, the peering request is accepted without a peering role.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html
    :cloudformationResource: AWS::EC2::VPCPeeringConnection
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPCPeering_connection = ec2.CfnVPCPeeringConnection(self, "MyCfnVPCPeeringConnection",
            peer_vpc_id="peerVpcId",
            vpc_id="vpcId",
        
            # the properties below are optional
            peer_owner_id="peerOwnerId",
            peer_region="peerRegion",
            peer_role_arn="peerRoleArn",
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        peer_vpc_id: builtins.str,
        vpc_id: builtins.str,
        peer_owner_id: typing.Optional[builtins.str] = None,
        peer_region: typing.Optional[builtins.str] = None,
        peer_role_arn: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param peer_vpc_id: The ID of the VPC with which you are creating the VPC peering connection. You must specify this parameter in the request.
        :param vpc_id: The ID of the VPC.
        :param peer_owner_id: The AWS account ID of the owner of the accepter VPC. Default: Your AWS account ID
        :param peer_region: The Region code for the accepter VPC, if the accepter VPC is located in a Region other than the Region in which you make the request. Default: The Region in which you make the request.
        :param peer_role_arn: The Amazon Resource Name (ARN) of the VPC peer role for the peering connection in another AWS account. This is required when you are peering a VPC in a different AWS account.
        :param tags: Any tags assigned to the resource.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__283f16af40ac820cdbf7878504f69ab5dc33365aace0c2be45d7515bdf764711)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPCPeeringConnectionProps(
            peer_vpc_id=peer_vpc_id,
            vpc_id=vpc_id,
            peer_owner_id=peer_owner_id,
            peer_region=peer_region,
            peer_role_arn=peer_role_arn,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a4e53245dec00e8851e1dd600141942f7df1471ef19b4373e05dbb18043678f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9c2a28bdb588c1f2ffa285ff2171d5740e05fca3e7b58a3f9bad65c7a90ffce)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the peering connection.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="peerVpcId")
    def peer_vpc_id(self) -> builtins.str:
        '''The ID of the VPC with which you are creating the VPC peering connection.'''
        return typing.cast(builtins.str, jsii.get(self, "peerVpcId"))

    @peer_vpc_id.setter
    def peer_vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aedf6ce3d2578b154db98299bf7ffa383ed7aceac5c744e9111ab5523eb64f1a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerVpcId", value)

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @vpc_id.setter
    def vpc_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82e22256c5137d1b0812e66eb90a5f2c67578576df13558b18ef25f37e65f5f2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpcId", value)

    @builtins.property
    @jsii.member(jsii_name="peerOwnerId")
    def peer_owner_id(self) -> typing.Optional[builtins.str]:
        '''The AWS account ID of the owner of the accepter VPC.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "peerOwnerId"))

    @peer_owner_id.setter
    def peer_owner_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3caac93b7771994a093ab7ef496c12437be78c55567256f7d201c81b4c05ce83)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerOwnerId", value)

    @builtins.property
    @jsii.member(jsii_name="peerRegion")
    def peer_region(self) -> typing.Optional[builtins.str]:
        '''The Region code for the accepter VPC, if the accepter VPC is located in a Region other than the Region in which you make the request.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "peerRegion"))

    @peer_region.setter
    def peer_region(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9208f42debbf50ce924fb422365716d6c4ad8cf43c1041d74ad9dde7a4c99287)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerRegion", value)

    @builtins.property
    @jsii.member(jsii_name="peerRoleArn")
    def peer_role_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the VPC peer role for the peering connection in another AWS account.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "peerRoleArn"))

    @peer_role_arn.setter
    def peer_role_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cdd72bcb19bc3cba191f4d943409326a497be999a3a4c30e5344ad41ca6f31d0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "peerRoleArn", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the resource.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd0acc940ee7b00909bee13ea3571aaed833a11db1602f2c73923e56aaddfda7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCPeeringConnectionProps",
    jsii_struct_bases=[],
    name_mapping={
        "peer_vpc_id": "peerVpcId",
        "vpc_id": "vpcId",
        "peer_owner_id": "peerOwnerId",
        "peer_region": "peerRegion",
        "peer_role_arn": "peerRoleArn",
        "tags": "tags",
    },
)
class CfnVPCPeeringConnectionProps:
    def __init__(
        self,
        *,
        peer_vpc_id: builtins.str,
        vpc_id: builtins.str,
        peer_owner_id: typing.Optional[builtins.str] = None,
        peer_region: typing.Optional[builtins.str] = None,
        peer_role_arn: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPCPeeringConnection``.

        :param peer_vpc_id: The ID of the VPC with which you are creating the VPC peering connection. You must specify this parameter in the request.
        :param vpc_id: The ID of the VPC.
        :param peer_owner_id: The AWS account ID of the owner of the accepter VPC. Default: Your AWS account ID
        :param peer_region: The Region code for the accepter VPC, if the accepter VPC is located in a Region other than the Region in which you make the request. Default: The Region in which you make the request.
        :param peer_role_arn: The Amazon Resource Name (ARN) of the VPC peer role for the peering connection in another AWS account. This is required when you are peering a VPC in a different AWS account.
        :param tags: Any tags assigned to the resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCPeering_connection_props = ec2.CfnVPCPeeringConnectionProps(
                peer_vpc_id="peerVpcId",
                vpc_id="vpcId",
            
                # the properties below are optional
                peer_owner_id="peerOwnerId",
                peer_region="peerRegion",
                peer_role_arn="peerRoleArn",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5424980a0758a93dfcbc06e12dba4559a33fc57d542bf705aca4fbc3aa6f52e)
            check_type(argname="argument peer_vpc_id", value=peer_vpc_id, expected_type=type_hints["peer_vpc_id"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument peer_owner_id", value=peer_owner_id, expected_type=type_hints["peer_owner_id"])
            check_type(argname="argument peer_region", value=peer_region, expected_type=type_hints["peer_region"])
            check_type(argname="argument peer_role_arn", value=peer_role_arn, expected_type=type_hints["peer_role_arn"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "peer_vpc_id": peer_vpc_id,
            "vpc_id": vpc_id,
        }
        if peer_owner_id is not None:
            self._values["peer_owner_id"] = peer_owner_id
        if peer_region is not None:
            self._values["peer_region"] = peer_region
        if peer_role_arn is not None:
            self._values["peer_role_arn"] = peer_role_arn
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def peer_vpc_id(self) -> builtins.str:
        '''The ID of the VPC with which you are creating the VPC peering connection.

        You must specify this parameter in the request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-peervpcid
        '''
        result = self._values.get("peer_vpc_id")
        assert result is not None, "Required property 'peer_vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The ID of the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-vpcid
        '''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def peer_owner_id(self) -> typing.Optional[builtins.str]:
        '''The AWS account ID of the owner of the accepter VPC.

        Default: Your AWS account ID

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-peerownerid
        '''
        result = self._values.get("peer_owner_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def peer_region(self) -> typing.Optional[builtins.str]:
        '''The Region code for the accepter VPC, if the accepter VPC is located in a Region other than the Region in which you make the request.

        Default: The Region in which you make the request.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-peerregion
        '''
        result = self._values.get("peer_region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def peer_role_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the VPC peer role for the peering connection in another AWS account.

        This is required when you are peering a VPC in a different AWS account.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-peerrolearn
        '''
        result = self._values.get("peer_role_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the resource.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html#cfn-ec2-vpcpeeringconnection-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCPeeringConnectionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPCProps",
    jsii_struct_bases=[],
    name_mapping={
        "cidr_block": "cidrBlock",
        "enable_dns_hostnames": "enableDnsHostnames",
        "enable_dns_support": "enableDnsSupport",
        "instance_tenancy": "instanceTenancy",
        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
        "ipv4_netmask_length": "ipv4NetmaskLength",
        "tags": "tags",
    },
)
class CfnVPCProps:
    def __init__(
        self,
        *,
        cidr_block: typing.Optional[builtins.str] = None,
        enable_dns_hostnames: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        enable_dns_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        instance_tenancy: typing.Optional[builtins.str] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPC``.

        :param cidr_block: The IPv4 network range for the VPC, in CIDR notation. For example, ``10.0.0.0/16`` . 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`` . You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .
        :param enable_dns_hostnames: Indicates whether the instances launched in the VPC get DNS hostnames. If enabled, instances in the VPC get DNS hostnames; otherwise, they do not. Disabled by default for nondefault VPCs. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ . You can only enable DNS hostnames if you've enabled DNS support.
        :param enable_dns_support: Indicates whether the DNS resolution is supported for the VPC. If enabled, queries to the Amazon provided DNS server at the 169.254.169.253 IP address, or the reserved IP address at the base of the VPC network range "plus two" succeed. If disabled, the Amazon provided DNS service in the VPC that resolves public DNS hostnames to IP addresses is not enabled. Enabled by default. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ .
        :param instance_tenancy: The allowed tenancy of instances launched into the VPC. - ``default`` : An instance launched into the VPC runs on shared hardware by default, unless you explicitly specify a different tenancy during instance launch. - ``dedicated`` : An instance launched into the VPC runs on dedicated hardware by default, unless you explicitly specify a tenancy of ``host`` during instance launch. You cannot specify a tenancy of ``default`` during instance launch. Updating ``InstanceTenancy`` requires no replacement only if you are updating its value from ``dedicated`` to ``default`` . Updating ``InstanceTenancy`` from ``default`` to ``dedicated`` requires replacement.
        :param ipv4_ipam_pool_id: The ID of an IPv4 IPAM pool you want to use for allocating this VPC's CIDR. For more information, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* . You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .
        :param ipv4_netmask_length: The netmask length of the IPv4 CIDR you want to allocate to this VPC from an Amazon VPC IP Address Manager (IPAM) pool. For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .
        :param tags: The tags for the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPCProps = ec2.CfnVPCProps(
                cidr_block="cidrBlock",
                enable_dns_hostnames=False,
                enable_dns_support=False,
                instance_tenancy="instanceTenancy",
                ipv4_ipam_pool_id="ipv4IpamPoolId",
                ipv4_netmask_length=123,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4533ebc56b9b17a3cedf2eb9ed9b46cc1677da7d71a319f06e950a5e32c57b4f)
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument enable_dns_hostnames", value=enable_dns_hostnames, expected_type=type_hints["enable_dns_hostnames"])
            check_type(argname="argument enable_dns_support", value=enable_dns_support, expected_type=type_hints["enable_dns_support"])
            check_type(argname="argument instance_tenancy", value=instance_tenancy, expected_type=type_hints["instance_tenancy"])
            check_type(argname="argument ipv4_ipam_pool_id", value=ipv4_ipam_pool_id, expected_type=type_hints["ipv4_ipam_pool_id"])
            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if enable_dns_hostnames is not None:
            self._values["enable_dns_hostnames"] = enable_dns_hostnames
        if enable_dns_support is not None:
            self._values["enable_dns_support"] = enable_dns_support
        if instance_tenancy is not None:
            self._values["instance_tenancy"] = instance_tenancy
        if ipv4_ipam_pool_id is not None:
            self._values["ipv4_ipam_pool_id"] = ipv4_ipam_pool_id
        if ipv4_netmask_length is not None:
            self._values["ipv4_netmask_length"] = ipv4_netmask_length
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 network range for the VPC, in CIDR notation.

        For example, ``10.0.0.0/16`` . 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`` .

        You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-cidrblock
        '''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enable_dns_hostnames(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the instances launched in the VPC get DNS hostnames.

        If enabled, instances in the VPC get DNS hostnames; otherwise, they do not. Disabled by default for nondefault VPCs. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ .

        You can only enable DNS hostnames if you've enabled DNS support.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-enablednshostnames
        '''
        result = self._values.get("enable_dns_hostnames")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def enable_dns_support(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the DNS resolution is supported for the VPC.

        If enabled, queries to the Amazon provided DNS server at the 169.254.169.253 IP address, or the reserved IP address at the base of the VPC network range "plus two" succeed. If disabled, the Amazon provided DNS service in the VPC that resolves public DNS hostnames to IP addresses is not enabled. Enabled by default. For more information, see `DNS attributes in your VPC <https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-enablednssupport
        '''
        result = self._values.get("enable_dns_support")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def instance_tenancy(self) -> typing.Optional[builtins.str]:
        '''The allowed tenancy of instances launched into the VPC.

        - ``default`` : An instance launched into the VPC runs on shared hardware by default, unless you explicitly specify a different tenancy during instance launch.
        - ``dedicated`` : An instance launched into the VPC runs on dedicated hardware by default, unless you explicitly specify a tenancy of ``host`` during instance launch. You cannot specify a tenancy of ``default`` during instance launch.

        Updating ``InstanceTenancy`` requires no replacement only if you are updating its value from ``dedicated`` to ``default`` . Updating ``InstanceTenancy`` from ``default`` to ``dedicated`` requires replacement.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-instancetenancy
        '''
        result = self._values.get("instance_tenancy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''The ID of an IPv4 IPAM pool you want to use for allocating this VPC's CIDR.

        For more information, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        You must specify either ``CidrBlock`` or ``Ipv4IpamPoolId`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-ipv4ipampoolid
        '''
        result = self._values.get("ipv4_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''The netmask length of the IPv4 CIDR you want to allocate to this VPC from an Amazon VPC IP Address Manager (IPAM) pool.

        For more information about IPAM, see `What is IPAM? <https://docs.aws.amazon.com//vpc/latest/ipam/what-is-it-ipam.html>`_ in the *Amazon VPC IPAM User Guide* .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-ipv4netmasklength
        '''
        result = self._values.get("ipv4_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags for the VPC.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#cfn-ec2-vpc-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPCProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVPNConnection(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNConnection",
):
    '''Specifies a VPN connection between a virtual private gateway and a VPN customer gateway or a transit gateway and a VPN customer gateway.

    To specify a VPN connection between a transit gateway and customer gateway, use the ``TransitGatewayId`` and ``CustomerGatewayId`` properties.

    To specify a VPN connection between a virtual private gateway and customer gateway, use the ``VpnGatewayId`` and ``CustomerGatewayId`` properties.

    For more information, see `AWS Site-to-Site VPN <https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html>`_ in the *AWS Site-to-Site VPN User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html
    :cloudformationResource: AWS::EC2::VPNConnection
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPNConnection = ec2.CfnVPNConnection(self, "MyCfnVPNConnection",
            customer_gateway_id="customerGatewayId",
            type="type",
        
            # the properties below are optional
            static_routes_only=False,
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            transit_gateway_id="transitGatewayId",
            vpn_gateway_id="vpnGatewayId",
            vpn_tunnel_options_specifications=[ec2.CfnVPNConnection.VpnTunnelOptionsSpecificationProperty(
                pre_shared_key="preSharedKey",
                tunnel_inside_cidr="tunnelInsideCidr"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        customer_gateway_id: builtins.str,
        type: builtins.str,
        static_routes_only: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transit_gateway_id: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
        vpn_tunnel_options_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVPNConnection.VpnTunnelOptionsSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param customer_gateway_id: The ID of the customer gateway at your end of the VPN connection.
        :param type: The type of VPN connection.
        :param static_routes_only: Indicates whether the VPN connection uses static routes only. Static routes must be used for devices that don't support BGP. If you are creating a VPN connection for a device that does not support Border Gateway Protocol (BGP), you must specify ``true`` .
        :param tags: Any tags assigned to the VPN connection.
        :param transit_gateway_id: The ID of the transit gateway associated with the VPN connection. You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_gateway_id: The ID of the virtual private gateway at the AWS side of the VPN connection. You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_tunnel_options_specifications: The tunnel options for the VPN connection.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e77cb0020f820726a03bfb8968e16674c7c5924b0f133f50aeda1623f31d6d55)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPNConnectionProps(
            customer_gateway_id=customer_gateway_id,
            type=type,
            static_routes_only=static_routes_only,
            tags=tags,
            transit_gateway_id=transit_gateway_id,
            vpn_gateway_id=vpn_gateway_id,
            vpn_tunnel_options_specifications=vpn_tunnel_options_specifications,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c032f6cb3a85e604e1c909c281575f6045b37bc3b2687fd6f712fb70192837a2)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc1b950a80a4fe71844cc3fb3fef45a30e33bdcba45a7397c635c943176eeb91)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrVpnConnectionId")
    def attr_vpn_connection_id(self) -> builtins.str:
        '''The ID of the VPN connection.

        :cloudformationAttribute: VpnConnectionId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpnConnectionId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    def customer_gateway_id(self) -> builtins.str:
        '''The ID of the customer gateway at your end of the VPN connection.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayId"))

    @customer_gateway_id.setter
    def customer_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b8ee030670b1b9643fa4d07392b8ca16dfb2b4c74b9f2614b03645b72d453e91)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "customerGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''The type of VPN connection.'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

    @type.setter
    def type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__59feaba339bd40609d7cfeabfd1d3a6faa58b8495f350550071b7ac9e9e5b7a3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value)

    @builtins.property
    @jsii.member(jsii_name="staticRoutesOnly")
    def static_routes_only(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the VPN connection uses static routes only.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "staticRoutesOnly"))

    @static_routes_only.setter
    def static_routes_only(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6cd3e38d95994ecfc9ca7d55958632e80d3f4b2d30513ab106e3fe76821aacf)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "staticRoutesOnly", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the VPN connection.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__938f7fab03256c6dcde99c3812a0afcd1e1d67abbff79e50a09b2286bbae4251)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="transitGatewayId")
    def transit_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the transit gateway associated with the VPN connection.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "transitGatewayId"))

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__863c644d46be7fb81e39a402d096afcdf597ce502577d6486a258bb4900ccdf9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "transitGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual private gateway at the AWS side of the VPN connection.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpnGatewayId"))

    @vpn_gateway_id.setter
    def vpn_gateway_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__68e0671a952b233ef44cb4e18db3052fff5636ca696c56590e9879c95154ce05)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnGatewayId", value)

    @builtins.property
    @jsii.member(jsii_name="vpnTunnelOptionsSpecifications")
    def vpn_tunnel_options_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVPNConnection.VpnTunnelOptionsSpecificationProperty"]]]]:
        '''The tunnel options for the VPN connection.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVPNConnection.VpnTunnelOptionsSpecificationProperty"]]]], jsii.get(self, "vpnTunnelOptionsSpecifications"))

    @vpn_tunnel_options_specifications.setter
    def vpn_tunnel_options_specifications(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVPNConnection.VpnTunnelOptionsSpecificationProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e5141022cbe7f67d8c3189c0b096230c58a40a82fd75e0a817bb5321c52e1a9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnTunnelOptionsSpecifications", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVPNConnection.VpnTunnelOptionsSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "pre_shared_key": "preSharedKey",
            "tunnel_inside_cidr": "tunnelInsideCidr",
        },
    )
    class VpnTunnelOptionsSpecificationProperty:
        def __init__(
            self,
            *,
            pre_shared_key: typing.Optional[builtins.str] = None,
            tunnel_inside_cidr: typing.Optional[builtins.str] = None,
        ) -> None:
            '''The tunnel options for a single VPN tunnel.

            :param pre_shared_key: The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway. Constraints: Allowed characters are alphanumeric characters, periods (.), and underscores (_). Must be between 8 and 64 characters in length and cannot start with zero (0).
            :param tunnel_inside_cidr: The range of inside IP addresses for the tunnel. Any specified CIDR blocks must be unique across all VPN connections that use the same virtual private gateway. Constraints: A size /30 CIDR block from the ``169.254.0.0/16`` range. The following CIDR blocks are reserved and cannot be used: - ``169.254.0.0/30`` - ``169.254.1.0/30`` - ``169.254.2.0/30`` - ``169.254.3.0/30`` - ``169.254.4.0/30`` - ``169.254.5.0/30`` - ``169.254.169.252/30``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-vpnconnection-vpntunneloptionsspecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                vpn_tunnel_options_specification_property = ec2.CfnVPNConnection.VpnTunnelOptionsSpecificationProperty(
                    pre_shared_key="preSharedKey",
                    tunnel_inside_cidr="tunnelInsideCidr"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c11a91303ade674ac2062d6f836f1c6c8a5ffcd828e189ee16a639aed0741e2c)
                check_type(argname="argument pre_shared_key", value=pre_shared_key, expected_type=type_hints["pre_shared_key"])
                check_type(argname="argument tunnel_inside_cidr", value=tunnel_inside_cidr, expected_type=type_hints["tunnel_inside_cidr"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if pre_shared_key is not None:
                self._values["pre_shared_key"] = pre_shared_key
            if tunnel_inside_cidr is not None:
                self._values["tunnel_inside_cidr"] = tunnel_inside_cidr

        @builtins.property
        def pre_shared_key(self) -> typing.Optional[builtins.str]:
            '''The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway.

            Constraints: Allowed characters are alphanumeric characters, periods (.), and underscores (_). Must be between 8 and 64 characters in length and cannot start with zero (0).

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-vpnconnection-vpntunneloptionsspecification.html#cfn-ec2-vpnconnection-vpntunneloptionsspecification-presharedkey
            '''
            result = self._values.get("pre_shared_key")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tunnel_inside_cidr(self) -> typing.Optional[builtins.str]:
            '''The range of inside IP addresses for the tunnel.

            Any specified CIDR blocks must be unique across all VPN connections that use the same virtual private gateway.

            Constraints: A size /30 CIDR block from the ``169.254.0.0/16`` range. The following CIDR blocks are reserved and cannot be used:

            - ``169.254.0.0/30``
            - ``169.254.1.0/30``
            - ``169.254.2.0/30``
            - ``169.254.3.0/30``
            - ``169.254.4.0/30``
            - ``169.254.5.0/30``
            - ``169.254.169.252/30``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-vpnconnection-vpntunneloptionsspecification.html#cfn-ec2-vpnconnection-vpntunneloptionsspecification-tunnelinsidecidr
            '''
            result = self._values.get("tunnel_inside_cidr")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VpnTunnelOptionsSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNConnectionProps",
    jsii_struct_bases=[],
    name_mapping={
        "customer_gateway_id": "customerGatewayId",
        "type": "type",
        "static_routes_only": "staticRoutesOnly",
        "tags": "tags",
        "transit_gateway_id": "transitGatewayId",
        "vpn_gateway_id": "vpnGatewayId",
        "vpn_tunnel_options_specifications": "vpnTunnelOptionsSpecifications",
    },
)
class CfnVPNConnectionProps:
    def __init__(
        self,
        *,
        customer_gateway_id: builtins.str,
        type: builtins.str,
        static_routes_only: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        transit_gateway_id: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
        vpn_tunnel_options_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVPNConnection.VpnTunnelOptionsSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPNConnection``.

        :param customer_gateway_id: The ID of the customer gateway at your end of the VPN connection.
        :param type: The type of VPN connection.
        :param static_routes_only: Indicates whether the VPN connection uses static routes only. Static routes must be used for devices that don't support BGP. If you are creating a VPN connection for a device that does not support Border Gateway Protocol (BGP), you must specify ``true`` .
        :param tags: Any tags assigned to the VPN connection.
        :param transit_gateway_id: The ID of the transit gateway associated with the VPN connection. You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_gateway_id: The ID of the virtual private gateway at the AWS side of the VPN connection. You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.
        :param vpn_tunnel_options_specifications: The tunnel options for the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPNConnection_props = ec2.CfnVPNConnectionProps(
                customer_gateway_id="customerGatewayId",
                type="type",
            
                # the properties below are optional
                static_routes_only=False,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                transit_gateway_id="transitGatewayId",
                vpn_gateway_id="vpnGatewayId",
                vpn_tunnel_options_specifications=[ec2.CfnVPNConnection.VpnTunnelOptionsSpecificationProperty(
                    pre_shared_key="preSharedKey",
                    tunnel_inside_cidr="tunnelInsideCidr"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af86adbb8c205a09b71896c35d8dac6b766cf096efd20c2deb4c2c01eea74408)
            check_type(argname="argument customer_gateway_id", value=customer_gateway_id, expected_type=type_hints["customer_gateway_id"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument static_routes_only", value=static_routes_only, expected_type=type_hints["static_routes_only"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument transit_gateway_id", value=transit_gateway_id, expected_type=type_hints["transit_gateway_id"])
            check_type(argname="argument vpn_gateway_id", value=vpn_gateway_id, expected_type=type_hints["vpn_gateway_id"])
            check_type(argname="argument vpn_tunnel_options_specifications", value=vpn_tunnel_options_specifications, expected_type=type_hints["vpn_tunnel_options_specifications"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "customer_gateway_id": customer_gateway_id,
            "type": type,
        }
        if static_routes_only is not None:
            self._values["static_routes_only"] = static_routes_only
        if tags is not None:
            self._values["tags"] = tags
        if transit_gateway_id is not None:
            self._values["transit_gateway_id"] = transit_gateway_id
        if vpn_gateway_id is not None:
            self._values["vpn_gateway_id"] = vpn_gateway_id
        if vpn_tunnel_options_specifications is not None:
            self._values["vpn_tunnel_options_specifications"] = vpn_tunnel_options_specifications

    @builtins.property
    def customer_gateway_id(self) -> builtins.str:
        '''The ID of the customer gateway at your end of the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-customergatewayid
        '''
        result = self._values.get("customer_gateway_id")
        assert result is not None, "Required property 'customer_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def type(self) -> builtins.str:
        '''The type of VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-type
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def static_routes_only(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the VPN connection uses static routes only.

        Static routes must be used for devices that don't support BGP.

        If you are creating a VPN connection for a device that does not support Border Gateway Protocol (BGP), you must specify ``true`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-staticroutesonly
        '''
        result = self._values.get("static_routes_only")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def transit_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the transit gateway associated with the VPN connection.

        You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-transitgatewayid
        '''
        result = self._values.get("transit_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the virtual private gateway at the AWS side of the VPN connection.

        You must specify either ``TransitGatewayId`` or ``VpnGatewayId`` , but not both.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-vpngatewayid
        '''
        result = self._values.get("vpn_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_tunnel_options_specifications(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVPNConnection.VpnTunnelOptionsSpecificationProperty]]]]:
        '''The tunnel options for the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnection.html#cfn-ec2-vpnconnection-vpntunneloptionsspecifications
        '''
        result = self._values.get("vpn_tunnel_options_specifications")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVPNConnection.VpnTunnelOptionsSpecificationProperty]]]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPNConnectionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPNConnectionRoute(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNConnectionRoute",
):
    '''Specifies a static route for a VPN connection between an existing virtual private gateway and a VPN customer gateway.

    The static route allows traffic to be routed from the virtual private gateway to the VPN customer gateway.

    For more information, see `AWS Site-to-Site VPN <https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html>`_ in the *AWS Site-to-Site VPN User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnectionroute.html
    :cloudformationResource: AWS::EC2::VPNConnectionRoute
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPNConnection_route = ec2.CfnVPNConnectionRoute(self, "MyCfnVPNConnectionRoute",
            destination_cidr_block="destinationCidrBlock",
            vpn_connection_id="vpnConnectionId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        destination_cidr_block: builtins.str,
        vpn_connection_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param destination_cidr_block: The CIDR block associated with the local subnet of the customer network.
        :param vpn_connection_id: The ID of the VPN connection.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62f5d72062803bba85ddfb772ace952f2d084839504c093614485b6ed47a1f4b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPNConnectionRouteProps(
            destination_cidr_block=destination_cidr_block,
            vpn_connection_id=vpn_connection_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__018cb671f4d662afcc429d96efa414f86b8478656300f96777beac1473bb097b)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a5735370729504da37e9032e10e7dade7cf4b741b7b1030d7412ada526157ad)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="destinationCidrBlock")
    def destination_cidr_block(self) -> builtins.str:
        '''The CIDR block associated with the local subnet of the customer network.'''
        return typing.cast(builtins.str, jsii.get(self, "destinationCidrBlock"))

    @destination_cidr_block.setter
    def destination_cidr_block(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__301b6c3d75b965dd9144974f533a6299f8a5031a16f3e6ce6d726cf0056f1fb8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "destinationCidrBlock", value)

    @builtins.property
    @jsii.member(jsii_name="vpnConnectionId")
    def vpn_connection_id(self) -> builtins.str:
        '''The ID of the VPN connection.'''
        return typing.cast(builtins.str, jsii.get(self, "vpnConnectionId"))

    @vpn_connection_id.setter
    def vpn_connection_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__94e27e66ecd12f654abae25e393a9e166f5a434c3c46f76396d88ae2e8d7a5b4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnConnectionId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNConnectionRouteProps",
    jsii_struct_bases=[],
    name_mapping={
        "destination_cidr_block": "destinationCidrBlock",
        "vpn_connection_id": "vpnConnectionId",
    },
)
class CfnVPNConnectionRouteProps:
    def __init__(
        self,
        *,
        destination_cidr_block: builtins.str,
        vpn_connection_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnVPNConnectionRoute``.

        :param destination_cidr_block: The CIDR block associated with the local subnet of the customer network.
        :param vpn_connection_id: The ID of the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnectionroute.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPNConnection_route_props = ec2.CfnVPNConnectionRouteProps(
                destination_cidr_block="destinationCidrBlock",
                vpn_connection_id="vpnConnectionId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8891e9566df17d3226ab7414fe88aeb135bee1fb42156b77ca3c05eb5e52e293)
            check_type(argname="argument destination_cidr_block", value=destination_cidr_block, expected_type=type_hints["destination_cidr_block"])
            check_type(argname="argument vpn_connection_id", value=vpn_connection_id, expected_type=type_hints["vpn_connection_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "destination_cidr_block": destination_cidr_block,
            "vpn_connection_id": vpn_connection_id,
        }

    @builtins.property
    def destination_cidr_block(self) -> builtins.str:
        '''The CIDR block associated with the local subnet of the customer network.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnectionroute.html#cfn-ec2-vpnconnectionroute-destinationcidrblock
        '''
        result = self._values.get("destination_cidr_block")
        assert result is not None, "Required property 'destination_cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpn_connection_id(self) -> builtins.str:
        '''The ID of the VPN connection.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpnconnectionroute.html#cfn-ec2-vpnconnectionroute-vpnconnectionid
        '''
        result = self._values.get("vpn_connection_id")
        assert result is not None, "Required property 'vpn_connection_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPNConnectionRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVPNGateway(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNGateway",
):
    '''Specifies a virtual private gateway.

    A virtual private gateway is the endpoint on the VPC side of your VPN connection. You can create a virtual private gateway before creating the VPC itself.

    For more information, see `AWS Site-to-Site VPN <https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html>`_ in the *AWS Site-to-Site VPN User Guide* .

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html
    :cloudformationResource: AWS::EC2::VPNGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPNGateway = ec2.CfnVPNGateway(self, "MyCfnVPNGateway",
            type="type",
        
            # the properties below are optional
            amazon_side_asn=123,
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param type: The type of VPN connection the virtual private gateway supports.
        :param amazon_side_asn: The private Autonomous System Number (ASN) for the Amazon side of a BGP session.
        :param tags: Any tags assigned to the virtual private gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30b37990cd28e78bbf86bb3095b8b6ccf2667a518f64b1c2703b84ca600ad12f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPNGatewayProps(
            type=type, amazon_side_asn=amazon_side_asn, tags=tags
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bec6f2401f76af768748e44f4b219c1c0e7bf274aea83c8308b9ba16a7f84088)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__77c3a3d9401386d2c855a95b876eca004e02fbae57178c1e633ed7e59d450922)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrVpnGatewayId")
    def attr_vpn_gateway_id(self) -> builtins.str:
        '''The ID of the VPN gateway.

        :cloudformationAttribute: VPNGatewayId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVpnGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''The type of VPN connection the virtual private gateway supports.'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

    @type.setter
    def type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfd4a16cd09365bbdd1ecdf3f779a819d4708d295b3443dbabd82e77bf9624b1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value)

    @builtins.property
    @jsii.member(jsii_name="amazonSideAsn")
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''The private Autonomous System Number (ASN) for the Amazon side of a BGP session.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "amazonSideAsn"))

    @amazon_side_asn.setter
    def amazon_side_asn(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__444b1fb958ac1a12c130cd92813cde4fd715d24f859e6b8bf7a1d1531f64e455)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "amazonSideAsn", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the virtual private gateway.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46ee07e6f81ec8800a47be0059211244f3fe11360f85c7d3a0f0723ff984062b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"type": "type", "amazon_side_asn": "amazonSideAsn", "tags": "tags"},
)
class CfnVPNGatewayProps:
    def __init__(
        self,
        *,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVPNGateway``.

        :param type: The type of VPN connection the virtual private gateway supports.
        :param amazon_side_asn: The private Autonomous System Number (ASN) for the Amazon side of a BGP session.
        :param tags: Any tags assigned to the virtual private gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPNGateway_props = ec2.CfnVPNGatewayProps(
                type="type",
            
                # the properties below are optional
                amazon_side_asn=123,
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79bb5db1bdc49a09c4960a1b24d8cc88e36ee93d9fba7beeb6372b60511e1a29)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument amazon_side_asn", value=amazon_side_asn, expected_type=type_hints["amazon_side_asn"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
        }
        if amazon_side_asn is not None:
            self._values["amazon_side_asn"] = amazon_side_asn
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def type(self) -> builtins.str:
        '''The type of VPN connection the virtual private gateway supports.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html#cfn-ec2-vpngateway-type
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''The private Autonomous System Number (ASN) for the Amazon side of a BGP session.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html#cfn-ec2-vpngateway-amazonsideasn
        '''
        result = self._values.get("amazon_side_asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''Any tags assigned to the virtual private gateway.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html#cfn-ec2-vpngateway-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPNGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556)
class CfnVPNGatewayRoutePropagation(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNGatewayRoutePropagation",
):
    '''Enables a virtual private gateway (VGW) to propagate routes to the specified route table of a VPC.

    If you reference a VPN gateway that is in the same template as your VPN gateway route propagation, you must explicitly declare a dependency on the VPN gateway attachment. The ``AWS::EC2::VPNGatewayRoutePropagation`` resource cannot use the VPN 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::VPNGatewayRoutePropagation`` resource to explicitly declare a dependency on the VPN gateway attachment.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngatewayroutepropagation.html
    :cloudformationResource: AWS::EC2::VPNGatewayRoutePropagation
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_vPNGateway_route_propagation = ec2.CfnVPNGatewayRoutePropagation(self, "MyCfnVPNGatewayRoutePropagation",
            route_table_ids=["routeTableIds"],
            vpn_gateway_id="vpnGatewayId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        route_table_ids: typing.Sequence[builtins.str],
        vpn_gateway_id: builtins.str,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param route_table_ids: The ID of the route table. The routing table must be associated with the same VPC that the virtual private gateway is attached to.
        :param vpn_gateway_id: The ID of the virtual private gateway that is attached to a VPC. The virtual private gateway must be attached to the same VPC that the routing tables are associated with.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__72082dc868990f0a6bf65359c4e13c6bffbfb7a161dc63811a1cc4a97b34c8bc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVPNGatewayRoutePropagationProps(
            route_table_ids=route_table_ids, vpn_gateway_id=vpn_gateway_id
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76cbf30e0dbb3902340136a2f03dd9b928e14ef079cae574f42d97a1e9e4a161)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c75987cbb7bf572e6e3a39848f0b94c62c77e71999ea6386fc12aa417ebb3b7)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrId")
    def attr_id(self) -> builtins.str:
        '''The ID of the VPN gateway.

        :cloudformationAttribute: Id
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="routeTableIds")
    def route_table_ids(self) -> typing.List[builtins.str]:
        '''The ID of the route table.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "routeTableIds"))

    @route_table_ids.setter
    def route_table_ids(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84456ae403f511ecc26fe921e1a4c16b07f068858c6c4ed0618385986e82c865)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "routeTableIds", value)

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> builtins.str:
        '''The ID of the virtual private gateway that is attached to a VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpnGatewayId"))

    @vpn_gateway_id.setter
    def vpn_gateway_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d28a1ac9b80dd54e7f1024857eb164a6cb07540c423e8ef6ce2539574cc7c03)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "vpnGatewayId", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVPNGatewayRoutePropagationProps",
    jsii_struct_bases=[],
    name_mapping={
        "route_table_ids": "routeTableIds",
        "vpn_gateway_id": "vpnGatewayId",
    },
)
class CfnVPNGatewayRoutePropagationProps:
    def __init__(
        self,
        *,
        route_table_ids: typing.Sequence[builtins.str],
        vpn_gateway_id: builtins.str,
    ) -> None:
        '''Properties for defining a ``CfnVPNGatewayRoutePropagation``.

        :param route_table_ids: The ID of the route table. The routing table must be associated with the same VPC that the virtual private gateway is attached to.
        :param vpn_gateway_id: The ID of the virtual private gateway that is attached to a VPC. The virtual private gateway must be attached to the same VPC that the routing tables are associated with.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngatewayroutepropagation.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_vPNGateway_route_propagation_props = ec2.CfnVPNGatewayRoutePropagationProps(
                route_table_ids=["routeTableIds"],
                vpn_gateway_id="vpnGatewayId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4978b3e27b6b5b3acc1c3fd0c26b22bd9e1dfb57f459fb21bb4a137666cc80b9)
            check_type(argname="argument route_table_ids", value=route_table_ids, expected_type=type_hints["route_table_ids"])
            check_type(argname="argument vpn_gateway_id", value=vpn_gateway_id, expected_type=type_hints["vpn_gateway_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "route_table_ids": route_table_ids,
            "vpn_gateway_id": vpn_gateway_id,
        }

    @builtins.property
    def route_table_ids(self) -> typing.List[builtins.str]:
        '''The ID of the route table.

        The routing table must be associated with the same VPC that the virtual private gateway is attached to.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngatewayroutepropagation.html#cfn-ec2-vpngatewayroutepropagation-routetableids
        '''
        result = self._values.get("route_table_ids")
        assert result is not None, "Required property 'route_table_ids' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def vpn_gateway_id(self) -> builtins.str:
        '''The ID of the virtual private gateway that is attached to a VPC.

        The virtual private gateway must be attached to the same VPC that the routing tables are associated with.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngatewayroutepropagation.html#cfn-ec2-vpngatewayroutepropagation-vpngatewayid
        '''
        result = self._values.get("vpn_gateway_id")
        assert result is not None, "Required property 'vpn_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVPNGatewayRoutePropagationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVerifiedAccessEndpoint(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessEndpoint",
):
    '''An AWS Verified Access endpoint specifies the application that AWS Verified Access provides access to.

    It must be attached to an AWS Verified Access group. An AWS Verified Access endpoint must also have an attached access policy before you attached it to a group.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html
    :cloudformationResource: AWS::EC2::VerifiedAccessEndpoint
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_verified_access_endpoint = ec2.CfnVerifiedAccessEndpoint(self, "MyCfnVerifiedAccessEndpoint",
            application_domain="applicationDomain",
            attachment_type="attachmentType",
            domain_certificate_arn="domainCertificateArn",
            endpoint_domain_prefix="endpointDomainPrefix",
            endpoint_type="endpointType",
            verified_access_group_id="verifiedAccessGroupId",
        
            # the properties below are optional
            description="description",
            load_balancer_options=ec2.CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty(
                load_balancer_arn="loadBalancerArn",
                port=123,
                protocol="protocol",
                subnet_ids=["subnetIds"]
            ),
            network_interface_options=ec2.CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty(
                network_interface_id="networkInterfaceId",
                port=123,
                protocol="protocol"
            ),
            policy_document="policyDocument",
            policy_enabled=False,
            security_group_ids=["securityGroupIds"],
            sse_specification=ec2.CfnVerifiedAccessEndpoint.SseSpecificationProperty(
                customer_managed_key_enabled=False,
                kms_key_arn="kmsKeyArn"
            ),
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        application_domain: builtins.str,
        attachment_type: builtins.str,
        domain_certificate_arn: builtins.str,
        endpoint_domain_prefix: builtins.str,
        endpoint_type: builtins.str,
        verified_access_group_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        load_balancer_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        network_interface_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        policy_document: typing.Optional[builtins.str] = None,
        policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessEndpoint.SseSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param application_domain: The DNS name for users to reach your application.
        :param attachment_type: The type of attachment used to provide connectivity between the AWS Verified Access endpoint and the application.
        :param domain_certificate_arn: The ARN of a public TLS/SSL certificate imported into or created with ACM.
        :param endpoint_domain_prefix: A custom identifier that is prepended to the DNS name that is generated for the endpoint.
        :param endpoint_type: The type of AWS Verified Access endpoint. Incoming application requests will be sent to an IP address, load balancer or a network interface depending on the endpoint type specified.
        :param verified_access_group_id: The ID of the AWS Verified Access group.
        :param description: A description for the AWS Verified Access endpoint.
        :param load_balancer_options: The load balancer details if creating the AWS Verified Access endpoint as ``load-balancer`` type.
        :param network_interface_options: The options for network-interface type endpoint.
        :param policy_document: The Verified Access policy document.
        :param policy_enabled: The status of the Verified Access policy.
        :param security_group_ids: The IDs of the security groups for the endpoint.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4d36b12d1ab3c67a3dfcd9bfed6cbbcb2f1267d23c43d3209213bf00969e5f91)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVerifiedAccessEndpointProps(
            application_domain=application_domain,
            attachment_type=attachment_type,
            domain_certificate_arn=domain_certificate_arn,
            endpoint_domain_prefix=endpoint_domain_prefix,
            endpoint_type=endpoint_type,
            verified_access_group_id=verified_access_group_id,
            description=description,
            load_balancer_options=load_balancer_options,
            network_interface_options=network_interface_options,
            policy_document=policy_document,
            policy_enabled=policy_enabled,
            security_group_ids=security_group_ids,
            sse_specification=sse_specification,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__abb70fea7de6ecd9de5e606c92990b20776b67f68e61fe0266304d7bcb9ff072)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bc2a2c5e187d55f32f86bed24144fa2c14723e28c2c028062d6941f44ca9e89d)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The creation time.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrDeviceValidationDomain")
    def attr_device_validation_domain(self) -> builtins.str:
        '''Use this to construct the redirect URI to add to your OIDC provider's allow list.

        :cloudformationAttribute: DeviceValidationDomain
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrDeviceValidationDomain"))

    @builtins.property
    @jsii.member(jsii_name="attrEndpointDomain")
    def attr_endpoint_domain(self) -> builtins.str:
        '''The DNS name generated for the endpoint.

        :cloudformationAttribute: EndpointDomain
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrEndpointDomain"))

    @builtins.property
    @jsii.member(jsii_name="attrLastUpdatedTime")
    def attr_last_updated_time(self) -> builtins.str:
        '''The last updated time.

        :cloudformationAttribute: LastUpdatedTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLastUpdatedTime"))

    @builtins.property
    @jsii.member(jsii_name="attrStatus")
    def attr_status(self) -> builtins.str:
        '''The endpoint status.

        :cloudformationAttribute: Status
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrStatus"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessEndpointId")
    def attr_verified_access_endpoint_id(self) -> builtins.str:
        '''The ID of the Verified Access endpoint.

        :cloudformationAttribute: VerifiedAccessEndpointId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessEndpointId"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessInstanceId")
    def attr_verified_access_instance_id(self) -> builtins.str:
        '''The instance identifier.

        :cloudformationAttribute: VerifiedAccessInstanceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessInstanceId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="applicationDomain")
    def application_domain(self) -> builtins.str:
        '''The DNS name for users to reach your application.'''
        return typing.cast(builtins.str, jsii.get(self, "applicationDomain"))

    @application_domain.setter
    def application_domain(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b28061f28b3f28be486d48f7dc7fd621f3103258eb9e7885ff475e46e5fd902b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "applicationDomain", value)

    @builtins.property
    @jsii.member(jsii_name="attachmentType")
    def attachment_type(self) -> builtins.str:
        '''The type of attachment used to provide connectivity between the AWS Verified Access endpoint and the application.'''
        return typing.cast(builtins.str, jsii.get(self, "attachmentType"))

    @attachment_type.setter
    def attachment_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d10e167e554b430eb1ac5650dc7e833d44fb08c080f0db7bddc1e8a7fc72cb1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "attachmentType", value)

    @builtins.property
    @jsii.member(jsii_name="domainCertificateArn")
    def domain_certificate_arn(self) -> builtins.str:
        '''The ARN of a public TLS/SSL certificate imported into or created with ACM.'''
        return typing.cast(builtins.str, jsii.get(self, "domainCertificateArn"))

    @domain_certificate_arn.setter
    def domain_certificate_arn(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efc1ee2a591d8925ff2f8ca9eaba761d65c8b57e365164d2a86e578e910f175f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "domainCertificateArn", value)

    @builtins.property
    @jsii.member(jsii_name="endpointDomainPrefix")
    def endpoint_domain_prefix(self) -> builtins.str:
        '''A custom identifier that is prepended to the DNS name that is generated for the endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "endpointDomainPrefix"))

    @endpoint_domain_prefix.setter
    def endpoint_domain_prefix(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff9d0e5773a8d9ea22993cc66220368ac095ea17382c558d7190b96a647f458f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "endpointDomainPrefix", value)

    @builtins.property
    @jsii.member(jsii_name="endpointType")
    def endpoint_type(self) -> builtins.str:
        '''The type of AWS Verified Access endpoint.'''
        return typing.cast(builtins.str, jsii.get(self, "endpointType"))

    @endpoint_type.setter
    def endpoint_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e1c912930012351cff79ab0fb5325f42f80c3484801d0cbe19a20d7a19cd8f3a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "endpointType", value)

    @builtins.property
    @jsii.member(jsii_name="verifiedAccessGroupId")
    def verified_access_group_id(self) -> builtins.str:
        '''The ID of the AWS Verified Access group.'''
        return typing.cast(builtins.str, jsii.get(self, "verifiedAccessGroupId"))

    @verified_access_group_id.setter
    def verified_access_group_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__89c39e6200e18904b3557bcd57dab1d8a26e87af526f5462ad34ddbffada9d08)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "verifiedAccessGroupId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access endpoint.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d4d12173aa39d537b02fbd1df1f0478890f6c89c75db9f7940f5afee0f771734)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="loadBalancerOptions")
    def load_balancer_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty"]]:
        '''The load balancer details if creating the AWS Verified Access endpoint as ``load-balancer`` type.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty"]], jsii.get(self, "loadBalancerOptions"))

    @load_balancer_options.setter
    def load_balancer_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__01b015d4e05a67fecfe59a236985e3c9ad8b2b7791748dd8c5d032d1bf017a03)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "loadBalancerOptions", value)

    @builtins.property
    @jsii.member(jsii_name="networkInterfaceOptions")
    def network_interface_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty"]]:
        '''The options for network-interface type endpoint.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty"]], jsii.get(self, "networkInterfaceOptions"))

    @network_interface_options.setter
    def network_interface_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e4b033be4b1684292884e782e482cc7e86bf5adf5cd06608d429f1c45141157)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "networkInterfaceOptions", value)

    @builtins.property
    @jsii.member(jsii_name="policyDocument")
    def policy_document(self) -> typing.Optional[builtins.str]:
        '''The Verified Access policy document.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "policyDocument"))

    @policy_document.setter
    def policy_document(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__655685c756b38b8b8a61041c012546a0287e1cb6ebb9e768c9d8f820c1180e8e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyDocument", value)

    @builtins.property
    @jsii.member(jsii_name="policyEnabled")
    def policy_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''The status of the Verified Access policy.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "policyEnabled"))

    @policy_enabled.setter
    def policy_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d544f882cc7fa74d192a81ca201822cd80d9f91a6c0680be92961c818a6eaa64)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="securityGroupIds")
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups for the endpoint.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "securityGroupIds"))

    @security_group_ids.setter
    def security_group_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__102770719c6031007d664c25a6414989d2e114f24811888a51575fc6a9fbbea8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "securityGroupIds", value)

    @builtins.property
    @jsii.member(jsii_name="sseSpecification")
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.SseSpecificationProperty"]]:
        '''The options for additional server side encryption.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.SseSpecificationProperty"]], jsii.get(self, "sseSpecification"))

    @sse_specification.setter
    def sse_specification(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessEndpoint.SseSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7156f5bb188e847d9f05c0e3e60f09d93517831c58bbed0fe93cc2ca53a27c08)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sseSpecification", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3d819c87bb8f385fc1e857a7fa5b0c4d1892fee609cc4cc3aa40264566a5ba4)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "load_balancer_arn": "loadBalancerArn",
            "port": "port",
            "protocol": "protocol",
            "subnet_ids": "subnetIds",
        },
    )
    class LoadBalancerOptionsProperty:
        def __init__(
            self,
            *,
            load_balancer_arn: typing.Optional[builtins.str] = None,
            port: typing.Optional[jsii.Number] = None,
            protocol: typing.Optional[builtins.str] = None,
            subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        ) -> None:
            '''Describes the load balancer options when creating an AWS Verified Access endpoint using the ``load-balancer`` type.

            :param load_balancer_arn: The ARN of the load balancer.
            :param port: The IP port number.
            :param protocol: The IP protocol.
            :param subnet_ids: The IDs of the subnets.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-loadbalanceroptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                load_balancer_options_property = ec2.CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty(
                    load_balancer_arn="loadBalancerArn",
                    port=123,
                    protocol="protocol",
                    subnet_ids=["subnetIds"]
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__748e5ad8bcd3de0f9d4460d24ba08621e5769f4aa625427a31af6f4cfad10c64)
                check_type(argname="argument load_balancer_arn", value=load_balancer_arn, expected_type=type_hints["load_balancer_arn"])
                check_type(argname="argument port", value=port, expected_type=type_hints["port"])
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
                check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if load_balancer_arn is not None:
                self._values["load_balancer_arn"] = load_balancer_arn
            if port is not None:
                self._values["port"] = port
            if protocol is not None:
                self._values["protocol"] = protocol
            if subnet_ids is not None:
                self._values["subnet_ids"] = subnet_ids

        @builtins.property
        def load_balancer_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the load balancer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-loadbalanceroptions.html#cfn-ec2-verifiedaccessendpoint-loadbalanceroptions-loadbalancerarn
            '''
            result = self._values.get("load_balancer_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def port(self) -> typing.Optional[jsii.Number]:
            '''The IP port number.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-loadbalanceroptions.html#cfn-ec2-verifiedaccessendpoint-loadbalanceroptions-port
            '''
            result = self._values.get("port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The IP protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-loadbalanceroptions.html#cfn-ec2-verifiedaccessendpoint-loadbalanceroptions-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
            '''The IDs of the subnets.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-loadbalanceroptions.html#cfn-ec2-verifiedaccessendpoint-loadbalanceroptions-subnetids
            '''
            result = self._values.get("subnet_ids")
            return typing.cast(typing.Optional[typing.List[builtins.str]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "LoadBalancerOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "network_interface_id": "networkInterfaceId",
            "port": "port",
            "protocol": "protocol",
        },
    )
    class NetworkInterfaceOptionsProperty:
        def __init__(
            self,
            *,
            network_interface_id: typing.Optional[builtins.str] = None,
            port: typing.Optional[jsii.Number] = None,
            protocol: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the network interface options when creating an AWS Verified Access endpoint using the ``network-interface`` type.

            :param network_interface_id: The ID of the network interface.
            :param port: The IP port number.
            :param protocol: The IP protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-networkinterfaceoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                network_interface_options_property = ec2.CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty(
                    network_interface_id="networkInterfaceId",
                    port=123,
                    protocol="protocol"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__87a3b1db27ee0d26aa10f209574558cadfa966a187d72396dc2453f49f105d43)
                check_type(argname="argument network_interface_id", value=network_interface_id, expected_type=type_hints["network_interface_id"])
                check_type(argname="argument port", value=port, expected_type=type_hints["port"])
                check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if network_interface_id is not None:
                self._values["network_interface_id"] = network_interface_id
            if port is not None:
                self._values["port"] = port
            if protocol is not None:
                self._values["protocol"] = protocol

        @builtins.property
        def network_interface_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the network interface.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-networkinterfaceoptions.html#cfn-ec2-verifiedaccessendpoint-networkinterfaceoptions-networkinterfaceid
            '''
            result = self._values.get("network_interface_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def port(self) -> typing.Optional[jsii.Number]:
            '''The IP port number.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-networkinterfaceoptions.html#cfn-ec2-verifiedaccessendpoint-networkinterfaceoptions-port
            '''
            result = self._values.get("port")
            return typing.cast(typing.Optional[jsii.Number], result)

        @builtins.property
        def protocol(self) -> typing.Optional[builtins.str]:
            '''The IP protocol.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-networkinterfaceoptions.html#cfn-ec2-verifiedaccessendpoint-networkinterfaceoptions-protocol
            '''
            result = self._values.get("protocol")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "NetworkInterfaceOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessEndpoint.SseSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "customer_managed_key_enabled": "customerManagedKeyEnabled",
            "kms_key_arn": "kmsKeyArn",
        },
    )
    class SseSpecificationProperty:
        def __init__(
            self,
            *,
            customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            kms_key_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''AWS Verified Access provides server side encryption by default to data at rest using AWS -owned KMS keys.

            You also have the option of using customer managed KMS keys, which can be specified using the options below.

            :param customer_managed_key_enabled: Enable or disable the use of customer managed KMS keys for server side encryption. Valid values: ``True`` | ``False``
            :param kms_key_arn: The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-ssespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                sse_specification_property = ec2.CfnVerifiedAccessEndpoint.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__02c635a2da8a4b8f86f38bec4cdb7864386d5f2c0ddad83ce923502ececa7167)
                check_type(argname="argument customer_managed_key_enabled", value=customer_managed_key_enabled, expected_type=type_hints["customer_managed_key_enabled"])
                check_type(argname="argument kms_key_arn", value=kms_key_arn, expected_type=type_hints["kms_key_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if customer_managed_key_enabled is not None:
                self._values["customer_managed_key_enabled"] = customer_managed_key_enabled
            if kms_key_arn is not None:
                self._values["kms_key_arn"] = kms_key_arn

        @builtins.property
        def customer_managed_key_enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Enable or disable the use of customer managed KMS keys for server side encryption.

            Valid values: ``True`` | ``False``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-ssespecification.html#cfn-ec2-verifiedaccessendpoint-ssespecification-customermanagedkeyenabled
            '''
            result = self._values.get("customer_managed_key_enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def kms_key_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessendpoint-ssespecification.html#cfn-ec2-verifiedaccessendpoint-ssespecification-kmskeyarn
            '''
            result = self._values.get("kms_key_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SseSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessEndpointProps",
    jsii_struct_bases=[],
    name_mapping={
        "application_domain": "applicationDomain",
        "attachment_type": "attachmentType",
        "domain_certificate_arn": "domainCertificateArn",
        "endpoint_domain_prefix": "endpointDomainPrefix",
        "endpoint_type": "endpointType",
        "verified_access_group_id": "verifiedAccessGroupId",
        "description": "description",
        "load_balancer_options": "loadBalancerOptions",
        "network_interface_options": "networkInterfaceOptions",
        "policy_document": "policyDocument",
        "policy_enabled": "policyEnabled",
        "security_group_ids": "securityGroupIds",
        "sse_specification": "sseSpecification",
        "tags": "tags",
    },
)
class CfnVerifiedAccessEndpointProps:
    def __init__(
        self,
        *,
        application_domain: builtins.str,
        attachment_type: builtins.str,
        domain_certificate_arn: builtins.str,
        endpoint_domain_prefix: builtins.str,
        endpoint_type: builtins.str,
        verified_access_group_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        load_balancer_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        network_interface_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        policy_document: typing.Optional[builtins.str] = None,
        policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVerifiedAccessEndpoint``.

        :param application_domain: The DNS name for users to reach your application.
        :param attachment_type: The type of attachment used to provide connectivity between the AWS Verified Access endpoint and the application.
        :param domain_certificate_arn: The ARN of a public TLS/SSL certificate imported into or created with ACM.
        :param endpoint_domain_prefix: A custom identifier that is prepended to the DNS name that is generated for the endpoint.
        :param endpoint_type: The type of AWS Verified Access endpoint. Incoming application requests will be sent to an IP address, load balancer or a network interface depending on the endpoint type specified.
        :param verified_access_group_id: The ID of the AWS Verified Access group.
        :param description: A description for the AWS Verified Access endpoint.
        :param load_balancer_options: The load balancer details if creating the AWS Verified Access endpoint as ``load-balancer`` type.
        :param network_interface_options: The options for network-interface type endpoint.
        :param policy_document: The Verified Access policy document.
        :param policy_enabled: The status of the Verified Access policy.
        :param security_group_ids: The IDs of the security groups for the endpoint.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_verified_access_endpoint_props = ec2.CfnVerifiedAccessEndpointProps(
                application_domain="applicationDomain",
                attachment_type="attachmentType",
                domain_certificate_arn="domainCertificateArn",
                endpoint_domain_prefix="endpointDomainPrefix",
                endpoint_type="endpointType",
                verified_access_group_id="verifiedAccessGroupId",
            
                # the properties below are optional
                description="description",
                load_balancer_options=ec2.CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty(
                    load_balancer_arn="loadBalancerArn",
                    port=123,
                    protocol="protocol",
                    subnet_ids=["subnetIds"]
                ),
                network_interface_options=ec2.CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty(
                    network_interface_id="networkInterfaceId",
                    port=123,
                    protocol="protocol"
                ),
                policy_document="policyDocument",
                policy_enabled=False,
                security_group_ids=["securityGroupIds"],
                sse_specification=ec2.CfnVerifiedAccessEndpoint.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                ),
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a6b5fcbc7d5ca5da1405e117289abdd54dfab30dc79e867da0da32239d886ee5)
            check_type(argname="argument application_domain", value=application_domain, expected_type=type_hints["application_domain"])
            check_type(argname="argument attachment_type", value=attachment_type, expected_type=type_hints["attachment_type"])
            check_type(argname="argument domain_certificate_arn", value=domain_certificate_arn, expected_type=type_hints["domain_certificate_arn"])
            check_type(argname="argument endpoint_domain_prefix", value=endpoint_domain_prefix, expected_type=type_hints["endpoint_domain_prefix"])
            check_type(argname="argument endpoint_type", value=endpoint_type, expected_type=type_hints["endpoint_type"])
            check_type(argname="argument verified_access_group_id", value=verified_access_group_id, expected_type=type_hints["verified_access_group_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument load_balancer_options", value=load_balancer_options, expected_type=type_hints["load_balancer_options"])
            check_type(argname="argument network_interface_options", value=network_interface_options, expected_type=type_hints["network_interface_options"])
            check_type(argname="argument policy_document", value=policy_document, expected_type=type_hints["policy_document"])
            check_type(argname="argument policy_enabled", value=policy_enabled, expected_type=type_hints["policy_enabled"])
            check_type(argname="argument security_group_ids", value=security_group_ids, expected_type=type_hints["security_group_ids"])
            check_type(argname="argument sse_specification", value=sse_specification, expected_type=type_hints["sse_specification"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "application_domain": application_domain,
            "attachment_type": attachment_type,
            "domain_certificate_arn": domain_certificate_arn,
            "endpoint_domain_prefix": endpoint_domain_prefix,
            "endpoint_type": endpoint_type,
            "verified_access_group_id": verified_access_group_id,
        }
        if description is not None:
            self._values["description"] = description
        if load_balancer_options is not None:
            self._values["load_balancer_options"] = load_balancer_options
        if network_interface_options is not None:
            self._values["network_interface_options"] = network_interface_options
        if policy_document is not None:
            self._values["policy_document"] = policy_document
        if policy_enabled is not None:
            self._values["policy_enabled"] = policy_enabled
        if security_group_ids is not None:
            self._values["security_group_ids"] = security_group_ids
        if sse_specification is not None:
            self._values["sse_specification"] = sse_specification
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def application_domain(self) -> builtins.str:
        '''The DNS name for users to reach your application.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-applicationdomain
        '''
        result = self._values.get("application_domain")
        assert result is not None, "Required property 'application_domain' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def attachment_type(self) -> builtins.str:
        '''The type of attachment used to provide connectivity between the AWS Verified Access endpoint and the application.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-attachmenttype
        '''
        result = self._values.get("attachment_type")
        assert result is not None, "Required property 'attachment_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def domain_certificate_arn(self) -> builtins.str:
        '''The ARN of a public TLS/SSL certificate imported into or created with ACM.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-domaincertificatearn
        '''
        result = self._values.get("domain_certificate_arn")
        assert result is not None, "Required property 'domain_certificate_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def endpoint_domain_prefix(self) -> builtins.str:
        '''A custom identifier that is prepended to the DNS name that is generated for the endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-endpointdomainprefix
        '''
        result = self._values.get("endpoint_domain_prefix")
        assert result is not None, "Required property 'endpoint_domain_prefix' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def endpoint_type(self) -> builtins.str:
        '''The type of AWS Verified Access endpoint.

        Incoming application requests will be sent to an IP address, load balancer or a network interface depending on the endpoint type specified.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-endpointtype
        '''
        result = self._values.get("endpoint_type")
        assert result is not None, "Required property 'endpoint_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def verified_access_group_id(self) -> builtins.str:
        '''The ID of the AWS Verified Access group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-verifiedaccessgroupid
        '''
        result = self._values.get("verified_access_group_id")
        assert result is not None, "Required property 'verified_access_group_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def load_balancer_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty]]:
        '''The load balancer details if creating the AWS Verified Access endpoint as ``load-balancer`` type.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-loadbalanceroptions
        '''
        result = self._values.get("load_balancer_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty]], result)

    @builtins.property
    def network_interface_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty]]:
        '''The options for network-interface type endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-networkinterfaceoptions
        '''
        result = self._values.get("network_interface_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty]], result)

    @builtins.property
    def policy_document(self) -> typing.Optional[builtins.str]:
        '''The Verified Access policy document.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-policydocument
        '''
        result = self._values.get("policy_document")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''The status of the Verified Access policy.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-policyenabled
        '''
        result = self._values.get("policy_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def security_group_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the security groups for the endpoint.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-securitygroupids
        '''
        result = self._values.get("security_group_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.SseSpecificationProperty]]:
        '''The options for additional server side encryption.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-ssespecification
        '''
        result = self._values.get("sse_specification")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.SseSpecificationProperty]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessendpoint.html#cfn-ec2-verifiedaccessendpoint-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVerifiedAccessEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVerifiedAccessGroup(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessGroup",
):
    '''An AWS Verified Access group is a collection of AWS Verified Access endpoints who's associated applications have similar security requirements.

    Each instance within a Verified Access group shares an Verified Access policy. For example, you can group all Verified Access instances associated with "sales" applications together and use one common Verified Access policy.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html
    :cloudformationResource: AWS::EC2::VerifiedAccessGroup
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_verified_access_group = ec2.CfnVerifiedAccessGroup(self, "MyCfnVerifiedAccessGroup",
            verified_access_instance_id="verifiedAccessInstanceId",
        
            # the properties below are optional
            description="description",
            policy_document="policyDocument",
            policy_enabled=False,
            sse_specification=ec2.CfnVerifiedAccessGroup.SseSpecificationProperty(
                customer_managed_key_enabled=False,
                kms_key_arn="kmsKeyArn"
            ),
            tags=[CfnTag(
                key="key",
                value="value"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        verified_access_instance_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        policy_document: typing.Optional[builtins.str] = None,
        policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessGroup.SseSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param verified_access_instance_id: The ID of the AWS Verified Access instance.
        :param description: A description for the AWS Verified Access group.
        :param policy_document: The Verified Access policy document.
        :param policy_enabled: The status of the Verified Access policy.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__febc0dfd1bf5844b4356256e7c6467491409eb1cda95c95317e8e03b55be995c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVerifiedAccessGroupProps(
            verified_access_instance_id=verified_access_instance_id,
            description=description,
            policy_document=policy_document,
            policy_enabled=policy_enabled,
            sse_specification=sse_specification,
            tags=tags,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dee012429baf2cb461e340b1cf429e6ca5f70012bb627476bfbf9d039199501f)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a4d2938c7ec5429f9c860a82a8eee6f48bb5770851dd45aad58d91ceef78e61)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The creation time.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrLastUpdatedTime")
    def attr_last_updated_time(self) -> builtins.str:
        '''The last updated time.

        :cloudformationAttribute: LastUpdatedTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLastUpdatedTime"))

    @builtins.property
    @jsii.member(jsii_name="attrOwner")
    def attr_owner(self) -> builtins.str:
        '''The ID of the AWS account that owns the group.

        :cloudformationAttribute: Owner
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrOwner"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessGroupArn")
    def attr_verified_access_group_arn(self) -> builtins.str:
        '''The ARN of the Verified Access group.

        :cloudformationAttribute: VerifiedAccessGroupArn
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessGroupArn"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessGroupId")
    def attr_verified_access_group_id(self) -> builtins.str:
        '''The ID of the Verified Access group.

        :cloudformationAttribute: VerifiedAccessGroupId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessGroupId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="verifiedAccessInstanceId")
    def verified_access_instance_id(self) -> builtins.str:
        '''The ID of the AWS Verified Access instance.'''
        return typing.cast(builtins.str, jsii.get(self, "verifiedAccessInstanceId"))

    @verified_access_instance_id.setter
    def verified_access_instance_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd1957d8d821c3ab381fe2f7a8b1b797089f01c610d4cbdf2bb30c065780b321)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "verifiedAccessInstanceId", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access group.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7aba4b12ab79b9b81cf832f871dca71142483f4f0d3602e13b86e5e1bb301acc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="policyDocument")
    def policy_document(self) -> typing.Optional[builtins.str]:
        '''The Verified Access policy document.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "policyDocument"))

    @policy_document.setter
    def policy_document(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ad42af95f5e36e38ec0b3430e344bd52f880a38113784068d9132df11825366c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyDocument", value)

    @builtins.property
    @jsii.member(jsii_name="policyEnabled")
    def policy_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''The status of the Verified Access policy.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "policyEnabled"))

    @policy_enabled.setter
    def policy_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8fdb63a3c9c468a3c2efe7f74eb56822b8ea9fd37530ce6c824319101a57d393)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="sseSpecification")
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessGroup.SseSpecificationProperty"]]:
        '''The options for additional server side encryption.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessGroup.SseSpecificationProperty"]], jsii.get(self, "sseSpecification"))

    @sse_specification.setter
    def sse_specification(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessGroup.SseSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca598abdce14557766e8bdb3540714b33b146846db4041f4bd06f01357aa26e6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sseSpecification", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96b483adf9d6f7282729e63f923c475bce48c71cf285f7937ba32321b69399db)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessGroup.SseSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "customer_managed_key_enabled": "customerManagedKeyEnabled",
            "kms_key_arn": "kmsKeyArn",
        },
    )
    class SseSpecificationProperty:
        def __init__(
            self,
            *,
            customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            kms_key_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''AWS Verified Access provides server side encryption by default to data at rest using AWS -owned KMS keys.

            You also have the option of using customer managed KMS keys, which can be specified using the options below.

            :param customer_managed_key_enabled: Enable or disable the use of customer managed KMS keys for server side encryption. Valid values: ``True`` | ``False``
            :param kms_key_arn: The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessgroup-ssespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                sse_specification_property = ec2.CfnVerifiedAccessGroup.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__986d725f46a507210471f6bdd732188014784f0fdd6b2784a4970b6d3eb8b1b6)
                check_type(argname="argument customer_managed_key_enabled", value=customer_managed_key_enabled, expected_type=type_hints["customer_managed_key_enabled"])
                check_type(argname="argument kms_key_arn", value=kms_key_arn, expected_type=type_hints["kms_key_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if customer_managed_key_enabled is not None:
                self._values["customer_managed_key_enabled"] = customer_managed_key_enabled
            if kms_key_arn is not None:
                self._values["kms_key_arn"] = kms_key_arn

        @builtins.property
        def customer_managed_key_enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Enable or disable the use of customer managed KMS keys for server side encryption.

            Valid values: ``True`` | ``False``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessgroup-ssespecification.html#cfn-ec2-verifiedaccessgroup-ssespecification-customermanagedkeyenabled
            '''
            result = self._values.get("customer_managed_key_enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def kms_key_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessgroup-ssespecification.html#cfn-ec2-verifiedaccessgroup-ssespecification-kmskeyarn
            '''
            result = self._values.get("kms_key_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SseSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessGroupProps",
    jsii_struct_bases=[],
    name_mapping={
        "verified_access_instance_id": "verifiedAccessInstanceId",
        "description": "description",
        "policy_document": "policyDocument",
        "policy_enabled": "policyEnabled",
        "sse_specification": "sseSpecification",
        "tags": "tags",
    },
)
class CfnVerifiedAccessGroupProps:
    def __init__(
        self,
        *,
        verified_access_instance_id: builtins.str,
        description: typing.Optional[builtins.str] = None,
        policy_document: typing.Optional[builtins.str] = None,
        policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessGroup.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVerifiedAccessGroup``.

        :param verified_access_instance_id: The ID of the AWS Verified Access instance.
        :param description: A description for the AWS Verified Access group.
        :param policy_document: The Verified Access policy document.
        :param policy_enabled: The status of the Verified Access policy.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_verified_access_group_props = ec2.CfnVerifiedAccessGroupProps(
                verified_access_instance_id="verifiedAccessInstanceId",
            
                # the properties below are optional
                description="description",
                policy_document="policyDocument",
                policy_enabled=False,
                sse_specification=ec2.CfnVerifiedAccessGroup.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                ),
                tags=[CfnTag(
                    key="key",
                    value="value"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a227e52aaf71829a5bd6ac823e30ca68b617f093528775cb853d4dfd9a667597)
            check_type(argname="argument verified_access_instance_id", value=verified_access_instance_id, expected_type=type_hints["verified_access_instance_id"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument policy_document", value=policy_document, expected_type=type_hints["policy_document"])
            check_type(argname="argument policy_enabled", value=policy_enabled, expected_type=type_hints["policy_enabled"])
            check_type(argname="argument sse_specification", value=sse_specification, expected_type=type_hints["sse_specification"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "verified_access_instance_id": verified_access_instance_id,
        }
        if description is not None:
            self._values["description"] = description
        if policy_document is not None:
            self._values["policy_document"] = policy_document
        if policy_enabled is not None:
            self._values["policy_enabled"] = policy_enabled
        if sse_specification is not None:
            self._values["sse_specification"] = sse_specification
        if tags is not None:
            self._values["tags"] = tags

    @builtins.property
    def verified_access_instance_id(self) -> builtins.str:
        '''The ID of the AWS Verified Access instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-verifiedaccessinstanceid
        '''
        result = self._values.get("verified_access_instance_id")
        assert result is not None, "Required property 'verified_access_instance_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access group.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy_document(self) -> typing.Optional[builtins.str]:
        '''The Verified Access policy document.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-policydocument
        '''
        result = self._values.get("policy_document")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def policy_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''The status of the Verified Access policy.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-policyenabled
        '''
        result = self._values.get("policy_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessGroup.SseSpecificationProperty]]:
        '''The options for additional server side encryption.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-ssespecification
        '''
        result = self._values.get("sse_specification")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessGroup.SseSpecificationProperty]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessgroup.html#cfn-ec2-verifiedaccessgroup-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVerifiedAccessGroupProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVerifiedAccessInstance(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance",
):
    '''An AWS Verified Access instance is a regional entity that evaluates application requests and grants access only when your security requirements are met.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html
    :cloudformationResource: AWS::EC2::VerifiedAccessInstance
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_verified_access_instance = ec2.CfnVerifiedAccessInstance(self, "MyCfnVerifiedAccessInstance",
            description="description",
            fips_enabled=False,
            logging_configurations=ec2.CfnVerifiedAccessInstance.VerifiedAccessLogsProperty(
                cloud_watch_logs=ec2.CfnVerifiedAccessInstance.CloudWatchLogsProperty(
                    enabled=False,
                    log_group="logGroup"
                ),
                include_trust_context=False,
                kinesis_data_firehose=ec2.CfnVerifiedAccessInstance.KinesisDataFirehoseProperty(
                    delivery_stream="deliveryStream",
                    enabled=False
                ),
                log_version="logVersion",
                s3=ec2.CfnVerifiedAccessInstance.S3Property(
                    bucket_name="bucketName",
                    bucket_owner="bucketOwner",
                    enabled=False,
                    prefix="prefix"
                )
            ),
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            verified_access_trust_provider_ids=["verifiedAccessTrustProviderIds"],
            verified_access_trust_providers=[ec2.CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty(
                description="description",
                device_trust_provider_type="deviceTrustProviderType",
                trust_provider_type="trustProviderType",
                user_trust_provider_type="userTrustProviderType",
                verified_access_trust_provider_id="verifiedAccessTrustProviderId"
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        description: typing.Optional[builtins.str] = None,
        fips_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        logging_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessInstance.VerifiedAccessLogsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        verified_access_trust_provider_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        verified_access_trust_providers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param description: A description for the AWS Verified Access instance.
        :param fips_enabled: Indicates whether support for Federal Information Processing Standards (FIPS) is enabled on the instance.
        :param logging_configurations: The logging configuration for the Verified Access instances.
        :param tags: The tags.
        :param verified_access_trust_provider_ids: The IDs of the AWS Verified Access trust providers.
        :param verified_access_trust_providers: The IDs of the AWS Verified Access trust providers.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__210b67953502d567079f8663990436a4ba8d53414d251da116ccd8eac9951667)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVerifiedAccessInstanceProps(
            description=description,
            fips_enabled=fips_enabled,
            logging_configurations=logging_configurations,
            tags=tags,
            verified_access_trust_provider_ids=verified_access_trust_provider_ids,
            verified_access_trust_providers=verified_access_trust_providers,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c0271cf05a81cceaa3b29ac96c0cad6feacfc39a01972257604533b896429b7)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0310f5df079f4d94843fdb4879da8562ae3108d66ec4cd10201c900aff51f0f6)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The creation time.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrLastUpdatedTime")
    def attr_last_updated_time(self) -> builtins.str:
        '''The last updated time.

        :cloudformationAttribute: LastUpdatedTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLastUpdatedTime"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessInstanceId")
    def attr_verified_access_instance_id(self) -> builtins.str:
        '''The ID of the Verified Access instance.

        :cloudformationAttribute: VerifiedAccessInstanceId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessInstanceId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access instance.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ba3dd03cf8f2db417bb16a3849e48282d3bd41790a0db527717302f3459305f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="fipsEnabled")
    def fips_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether support for Federal Information Processing Standards (FIPS) is enabled on the instance.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "fipsEnabled"))

    @fips_enabled.setter
    def fips_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__46f7e98a9ee27ebc4332a3a0b4bc5e72cf85aada2dafdbe68d3d16aafb3631ac)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "fipsEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="loggingConfigurations")
    def logging_configurations(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessLogsProperty"]]:
        '''The logging configuration for the Verified Access instances.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessLogsProperty"]], jsii.get(self, "loggingConfigurations"))

    @logging_configurations.setter
    def logging_configurations(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessLogsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4955f8f53f851348c8285cac4ecd1b039f966961bcff2cd543179160ada57973)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "loggingConfigurations", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__100282dc1aaba64acc97f9783bf1e1be20a97dfb87ea40204f93a334aab4f756)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="verifiedAccessTrustProviderIds")
    def verified_access_trust_provider_ids(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the AWS Verified Access trust providers.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "verifiedAccessTrustProviderIds"))

    @verified_access_trust_provider_ids.setter
    def verified_access_trust_provider_ids(
        self,
        value: typing.Optional[typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3c8d28849cc9dc92ee550528a94d5da78121111bce48c647902e6af09fdfb537)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "verifiedAccessTrustProviderIds", value)

    @builtins.property
    @jsii.member(jsii_name="verifiedAccessTrustProviders")
    def verified_access_trust_providers(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty"]]]]:
        '''The IDs of the AWS Verified Access trust providers.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty"]]]], jsii.get(self, "verifiedAccessTrustProviders"))

    @verified_access_trust_providers.setter
    def verified_access_trust_providers(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty"]]]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__27dd0a41155716b4183a01751d9d5f230565a6e03f23253780d8bf04c8b24e1f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "verifiedAccessTrustProviders", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance.CloudWatchLogsProperty",
        jsii_struct_bases=[],
        name_mapping={"enabled": "enabled", "log_group": "logGroup"},
    )
    class CloudWatchLogsProperty:
        def __init__(
            self,
            *,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            log_group: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Options for CloudWatch Logs as a logging destination.

            :param enabled: Indicates whether logging is enabled.
            :param log_group: The ID of the CloudWatch Logs log group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-cloudwatchlogs.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                cloud_watch_logs_property = ec2.CfnVerifiedAccessInstance.CloudWatchLogsProperty(
                    enabled=False,
                    log_group="logGroup"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__44bffef7b929e685f0e0e13a13be464cdc14cc4672e87b469af3fda94556699c)
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
                check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if enabled is not None:
                self._values["enabled"] = enabled
            if log_group is not None:
                self._values["log_group"] = log_group

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-cloudwatchlogs.html#cfn-ec2-verifiedaccessinstance-cloudwatchlogs-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def log_group(self) -> typing.Optional[builtins.str]:
            '''The ID of the CloudWatch Logs log group.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-cloudwatchlogs.html#cfn-ec2-verifiedaccessinstance-cloudwatchlogs-loggroup
            '''
            result = self._values.get("log_group")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "CloudWatchLogsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance.KinesisDataFirehoseProperty",
        jsii_struct_bases=[],
        name_mapping={"delivery_stream": "deliveryStream", "enabled": "enabled"},
    )
    class KinesisDataFirehoseProperty:
        def __init__(
            self,
            *,
            delivery_stream: typing.Optional[builtins.str] = None,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        ) -> None:
            '''Options for Kinesis as a logging destination.

            :param delivery_stream: The ID of the delivery stream.
            :param enabled: Indicates whether logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-kinesisdatafirehose.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                kinesis_data_firehose_property = ec2.CfnVerifiedAccessInstance.KinesisDataFirehoseProperty(
                    delivery_stream="deliveryStream",
                    enabled=False
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__54733b0f065eb2a9c0e450f9e84ab0fc1cfd0fcdcf1378adf014441333204f8f)
                check_type(argname="argument delivery_stream", value=delivery_stream, expected_type=type_hints["delivery_stream"])
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if delivery_stream is not None:
                self._values["delivery_stream"] = delivery_stream
            if enabled is not None:
                self._values["enabled"] = enabled

        @builtins.property
        def delivery_stream(self) -> typing.Optional[builtins.str]:
            '''The ID of the delivery stream.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-kinesisdatafirehose.html#cfn-ec2-verifiedaccessinstance-kinesisdatafirehose-deliverystream
            '''
            result = self._values.get("delivery_stream")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-kinesisdatafirehose.html#cfn-ec2-verifiedaccessinstance-kinesisdatafirehose-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "KinesisDataFirehoseProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance.S3Property",
        jsii_struct_bases=[],
        name_mapping={
            "bucket_name": "bucketName",
            "bucket_owner": "bucketOwner",
            "enabled": "enabled",
            "prefix": "prefix",
        },
    )
    class S3Property:
        def __init__(
            self,
            *,
            bucket_name: typing.Optional[builtins.str] = None,
            bucket_owner: typing.Optional[builtins.str] = None,
            enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            prefix: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Options for Amazon S3 as a logging destination.

            :param bucket_name: The bucket name.
            :param bucket_owner: The AWS account number that owns the bucket.
            :param enabled: Indicates whether logging is enabled.
            :param prefix: The bucket prefix.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-s3.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                s3_property = ec2.CfnVerifiedAccessInstance.S3Property(
                    bucket_name="bucketName",
                    bucket_owner="bucketOwner",
                    enabled=False,
                    prefix="prefix"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__dc970afb92be346ba67ba3fe83b5aae03c5555879c0974b909d72f4ff77e1cbd)
                check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
                check_type(argname="argument bucket_owner", value=bucket_owner, expected_type=type_hints["bucket_owner"])
                check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
                check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if bucket_name is not None:
                self._values["bucket_name"] = bucket_name
            if bucket_owner is not None:
                self._values["bucket_owner"] = bucket_owner
            if enabled is not None:
                self._values["enabled"] = enabled
            if prefix is not None:
                self._values["prefix"] = prefix

        @builtins.property
        def bucket_name(self) -> typing.Optional[builtins.str]:
            '''The bucket name.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-s3.html#cfn-ec2-verifiedaccessinstance-s3-bucketname
            '''
            result = self._values.get("bucket_name")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def bucket_owner(self) -> typing.Optional[builtins.str]:
            '''The AWS account number that owns the bucket.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-s3.html#cfn-ec2-verifiedaccessinstance-s3-bucketowner
            '''
            result = self._values.get("bucket_owner")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether logging is enabled.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-s3.html#cfn-ec2-verifiedaccessinstance-s3-enabled
            '''
            result = self._values.get("enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def prefix(self) -> typing.Optional[builtins.str]:
            '''The bucket prefix.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-s3.html#cfn-ec2-verifiedaccessinstance-s3-prefix
            '''
            result = self._values.get("prefix")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "S3Property(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance.VerifiedAccessLogsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "cloud_watch_logs": "cloudWatchLogs",
            "include_trust_context": "includeTrustContext",
            "kinesis_data_firehose": "kinesisDataFirehose",
            "log_version": "logVersion",
            "s3": "s3",
        },
    )
    class VerifiedAccessLogsProperty:
        def __init__(
            self,
            *,
            cloud_watch_logs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessInstance.CloudWatchLogsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            include_trust_context: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            kinesis_data_firehose: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessInstance.KinesisDataFirehoseProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
            log_version: typing.Optional[builtins.str] = None,
            s3: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessInstance.S3Property", typing.Dict[builtins.str, typing.Any]]]] = None,
        ) -> None:
            '''Describes the options for Verified Access logs.

            :param cloud_watch_logs: CloudWatch Logs logging destination.
            :param include_trust_context: Indicates whether to include trust data sent by trust providers in the logs.
            :param kinesis_data_firehose: Kinesis logging destination.
            :param log_version: The logging version. Valid values: ``ocsf-0.1`` | ``ocsf-1.0.0-rc.2``
            :param s3: Amazon S3 logging options.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                verified_access_logs_property = ec2.CfnVerifiedAccessInstance.VerifiedAccessLogsProperty(
                    cloud_watch_logs=ec2.CfnVerifiedAccessInstance.CloudWatchLogsProperty(
                        enabled=False,
                        log_group="logGroup"
                    ),
                    include_trust_context=False,
                    kinesis_data_firehose=ec2.CfnVerifiedAccessInstance.KinesisDataFirehoseProperty(
                        delivery_stream="deliveryStream",
                        enabled=False
                    ),
                    log_version="logVersion",
                    s3=ec2.CfnVerifiedAccessInstance.S3Property(
                        bucket_name="bucketName",
                        bucket_owner="bucketOwner",
                        enabled=False,
                        prefix="prefix"
                    )
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ca37305754055968c478f1947f0a7d8dd1d7b0566a8cd16dba7110112d42866e)
                check_type(argname="argument cloud_watch_logs", value=cloud_watch_logs, expected_type=type_hints["cloud_watch_logs"])
                check_type(argname="argument include_trust_context", value=include_trust_context, expected_type=type_hints["include_trust_context"])
                check_type(argname="argument kinesis_data_firehose", value=kinesis_data_firehose, expected_type=type_hints["kinesis_data_firehose"])
                check_type(argname="argument log_version", value=log_version, expected_type=type_hints["log_version"])
                check_type(argname="argument s3", value=s3, expected_type=type_hints["s3"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if cloud_watch_logs is not None:
                self._values["cloud_watch_logs"] = cloud_watch_logs
            if include_trust_context is not None:
                self._values["include_trust_context"] = include_trust_context
            if kinesis_data_firehose is not None:
                self._values["kinesis_data_firehose"] = kinesis_data_firehose
            if log_version is not None:
                self._values["log_version"] = log_version
            if s3 is not None:
                self._values["s3"] = s3

        @builtins.property
        def cloud_watch_logs(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.CloudWatchLogsProperty"]]:
            '''CloudWatch Logs logging destination.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html#cfn-ec2-verifiedaccessinstance-verifiedaccesslogs-cloudwatchlogs
            '''
            result = self._values.get("cloud_watch_logs")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.CloudWatchLogsProperty"]], result)

        @builtins.property
        def include_trust_context(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Indicates whether to include trust data sent by trust providers in the logs.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html#cfn-ec2-verifiedaccessinstance-verifiedaccesslogs-includetrustcontext
            '''
            result = self._values.get("include_trust_context")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def kinesis_data_firehose(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.KinesisDataFirehoseProperty"]]:
            '''Kinesis logging destination.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html#cfn-ec2-verifiedaccessinstance-verifiedaccesslogs-kinesisdatafirehose
            '''
            result = self._values.get("kinesis_data_firehose")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.KinesisDataFirehoseProperty"]], result)

        @builtins.property
        def log_version(self) -> typing.Optional[builtins.str]:
            '''The logging version.

            Valid values: ``ocsf-0.1`` | ``ocsf-1.0.0-rc.2``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html#cfn-ec2-verifiedaccessinstance-verifiedaccesslogs-logversion
            '''
            result = self._values.get("log_version")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def s3(
            self,
        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.S3Property"]]:
            '''Amazon S3 logging options.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesslogs.html#cfn-ec2-verifiedaccessinstance-verifiedaccesslogs-s3
            '''
            result = self._values.get("s3")
            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessInstance.S3Property"]], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VerifiedAccessLogsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty",
        jsii_struct_bases=[],
        name_mapping={
            "description": "description",
            "device_trust_provider_type": "deviceTrustProviderType",
            "trust_provider_type": "trustProviderType",
            "user_trust_provider_type": "userTrustProviderType",
            "verified_access_trust_provider_id": "verifiedAccessTrustProviderId",
        },
    )
    class VerifiedAccessTrustProviderProperty:
        def __init__(
            self,
            *,
            description: typing.Optional[builtins.str] = None,
            device_trust_provider_type: typing.Optional[builtins.str] = None,
            trust_provider_type: typing.Optional[builtins.str] = None,
            user_trust_provider_type: typing.Optional[builtins.str] = None,
            verified_access_trust_provider_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''A trust provider is a third-party entity that creates, maintains, and manages identity information for users and devices.

            When an application request is made, the identity information sent by the trust provider is evaluated by Verified Access before allowing or denying the application request.

            :param description: A description for the AWS Verified Access trust provider.
            :param device_trust_provider_type: The type of device-based trust provider.
            :param trust_provider_type: The type of Verified Access trust provider.
            :param user_trust_provider_type: The type of user-based trust provider.
            :param verified_access_trust_provider_id: The ID of the AWS Verified Access trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                verified_access_trust_provider_property = ec2.CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty(
                    description="description",
                    device_trust_provider_type="deviceTrustProviderType",
                    trust_provider_type="trustProviderType",
                    user_trust_provider_type="userTrustProviderType",
                    verified_access_trust_provider_id="verifiedAccessTrustProviderId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__aa1b1a9d00743fb82589cb1d8f7514bfaa414568bff92a69bc361d83017bbf87)
                check_type(argname="argument description", value=description, expected_type=type_hints["description"])
                check_type(argname="argument device_trust_provider_type", value=device_trust_provider_type, expected_type=type_hints["device_trust_provider_type"])
                check_type(argname="argument trust_provider_type", value=trust_provider_type, expected_type=type_hints["trust_provider_type"])
                check_type(argname="argument user_trust_provider_type", value=user_trust_provider_type, expected_type=type_hints["user_trust_provider_type"])
                check_type(argname="argument verified_access_trust_provider_id", value=verified_access_trust_provider_id, expected_type=type_hints["verified_access_trust_provider_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if description is not None:
                self._values["description"] = description
            if device_trust_provider_type is not None:
                self._values["device_trust_provider_type"] = device_trust_provider_type
            if trust_provider_type is not None:
                self._values["trust_provider_type"] = trust_provider_type
            if user_trust_provider_type is not None:
                self._values["user_trust_provider_type"] = user_trust_provider_type
            if verified_access_trust_provider_id is not None:
                self._values["verified_access_trust_provider_id"] = verified_access_trust_provider_id

        @builtins.property
        def description(self) -> typing.Optional[builtins.str]:
            '''A description for the AWS Verified Access trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustprovider-description
            '''
            result = self._values.get("description")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def device_trust_provider_type(self) -> typing.Optional[builtins.str]:
            '''The type of device-based trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustprovider-devicetrustprovidertype
            '''
            result = self._values.get("device_trust_provider_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def trust_provider_type(self) -> typing.Optional[builtins.str]:
            '''The type of Verified Access trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustprovider-trustprovidertype
            '''
            result = self._values.get("trust_provider_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def user_trust_provider_type(self) -> typing.Optional[builtins.str]:
            '''The type of user-based trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustprovider-usertrustprovidertype
            '''
            result = self._values.get("user_trust_provider_type")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def verified_access_trust_provider_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the AWS Verified Access trust provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccessinstance-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustprovider-verifiedaccesstrustproviderid
            '''
            result = self._values.get("verified_access_trust_provider_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "VerifiedAccessTrustProviderProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessInstanceProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "fips_enabled": "fipsEnabled",
        "logging_configurations": "loggingConfigurations",
        "tags": "tags",
        "verified_access_trust_provider_ids": "verifiedAccessTrustProviderIds",
        "verified_access_trust_providers": "verifiedAccessTrustProviders",
    },
)
class CfnVerifiedAccessInstanceProps:
    def __init__(
        self,
        *,
        description: typing.Optional[builtins.str] = None,
        fips_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        logging_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessLogsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        verified_access_trust_provider_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        verified_access_trust_providers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ) -> None:
        '''Properties for defining a ``CfnVerifiedAccessInstance``.

        :param description: A description for the AWS Verified Access instance.
        :param fips_enabled: Indicates whether support for Federal Information Processing Standards (FIPS) is enabled on the instance.
        :param logging_configurations: The logging configuration for the Verified Access instances.
        :param tags: The tags.
        :param verified_access_trust_provider_ids: The IDs of the AWS Verified Access trust providers.
        :param verified_access_trust_providers: The IDs of the AWS Verified Access trust providers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_verified_access_instance_props = ec2.CfnVerifiedAccessInstanceProps(
                description="description",
                fips_enabled=False,
                logging_configurations=ec2.CfnVerifiedAccessInstance.VerifiedAccessLogsProperty(
                    cloud_watch_logs=ec2.CfnVerifiedAccessInstance.CloudWatchLogsProperty(
                        enabled=False,
                        log_group="logGroup"
                    ),
                    include_trust_context=False,
                    kinesis_data_firehose=ec2.CfnVerifiedAccessInstance.KinesisDataFirehoseProperty(
                        delivery_stream="deliveryStream",
                        enabled=False
                    ),
                    log_version="logVersion",
                    s3=ec2.CfnVerifiedAccessInstance.S3Property(
                        bucket_name="bucketName",
                        bucket_owner="bucketOwner",
                        enabled=False,
                        prefix="prefix"
                    )
                ),
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                verified_access_trust_provider_ids=["verifiedAccessTrustProviderIds"],
                verified_access_trust_providers=[ec2.CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty(
                    description="description",
                    device_trust_provider_type="deviceTrustProviderType",
                    trust_provider_type="trustProviderType",
                    user_trust_provider_type="userTrustProviderType",
                    verified_access_trust_provider_id="verifiedAccessTrustProviderId"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9a24ec455946fcefd05480c5a9ec8b48ab899be4d2ad63a1acb976abdf7df46)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument fips_enabled", value=fips_enabled, expected_type=type_hints["fips_enabled"])
            check_type(argname="argument logging_configurations", value=logging_configurations, expected_type=type_hints["logging_configurations"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument verified_access_trust_provider_ids", value=verified_access_trust_provider_ids, expected_type=type_hints["verified_access_trust_provider_ids"])
            check_type(argname="argument verified_access_trust_providers", value=verified_access_trust_providers, expected_type=type_hints["verified_access_trust_providers"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if description is not None:
            self._values["description"] = description
        if fips_enabled is not None:
            self._values["fips_enabled"] = fips_enabled
        if logging_configurations is not None:
            self._values["logging_configurations"] = logging_configurations
        if tags is not None:
            self._values["tags"] = tags
        if verified_access_trust_provider_ids is not None:
            self._values["verified_access_trust_provider_ids"] = verified_access_trust_provider_ids
        if verified_access_trust_providers is not None:
            self._values["verified_access_trust_providers"] = verified_access_trust_providers

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def fips_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether support for Federal Information Processing Standards (FIPS) is enabled on the instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-fipsenabled
        '''
        result = self._values.get("fips_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def logging_configurations(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessLogsProperty]]:
        '''The logging configuration for the Verified Access instances.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-loggingconfigurations
        '''
        result = self._values.get("logging_configurations")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessLogsProperty]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def verified_access_trust_provider_ids(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''The IDs of the AWS Verified Access trust providers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustproviderids
        '''
        result = self._values.get("verified_access_trust_provider_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def verified_access_trust_providers(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty]]]]:
        '''The IDs of the AWS Verified Access trust providers.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccessinstance.html#cfn-ec2-verifiedaccessinstance-verifiedaccesstrustproviders
        '''
        result = self._values.get("verified_access_trust_providers")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty]]]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVerifiedAccessInstanceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVerifiedAccessTrustProvider(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessTrustProvider",
):
    '''A trust provider is a third-party entity that creates, maintains, and manages identity information for users and devices.

    When an application request is made, the identity information sent by the trust provider is evaluated by Verified Access before allowing or denying the application request.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html
    :cloudformationResource: AWS::EC2::VerifiedAccessTrustProvider
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_verified_access_trust_provider = ec2.CfnVerifiedAccessTrustProvider(self, "MyCfnVerifiedAccessTrustProvider",
            policy_reference_name="policyReferenceName",
            trust_provider_type="trustProviderType",
        
            # the properties below are optional
            description="description",
            device_options=ec2.CfnVerifiedAccessTrustProvider.DeviceOptionsProperty(
                public_signing_key_url="publicSigningKeyUrl",
                tenant_id="tenantId"
            ),
            device_trust_provider_type="deviceTrustProviderType",
            oidc_options=ec2.CfnVerifiedAccessTrustProvider.OidcOptionsProperty(
                authorization_endpoint="authorizationEndpoint",
                client_id="clientId",
                client_secret="clientSecret",
                issuer="issuer",
                scope="scope",
                token_endpoint="tokenEndpoint",
                user_info_endpoint="userInfoEndpoint"
            ),
            sse_specification=ec2.CfnVerifiedAccessTrustProvider.SseSpecificationProperty(
                customer_managed_key_enabled=False,
                kms_key_arn="kmsKeyArn"
            ),
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            user_trust_provider_type="userTrustProviderType"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        policy_reference_name: builtins.str,
        trust_provider_type: builtins.str,
        description: typing.Optional[builtins.str] = None,
        device_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessTrustProvider.DeviceOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        device_trust_provider_type: typing.Optional[builtins.str] = None,
        oidc_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessTrustProvider.OidcOptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnVerifiedAccessTrustProvider.SseSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        user_trust_provider_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param policy_reference_name: The identifier to be used when working with policy rules.
        :param trust_provider_type: The type of Verified Access trust provider.
        :param description: A description for the AWS Verified Access trust provider.
        :param device_options: The options for device-identity trust provider.
        :param device_trust_provider_type: The type of device-based trust provider.
        :param oidc_options: The options for an OpenID Connect-compatible user-identity trust provider.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.
        :param user_trust_provider_type: The type of user-based trust provider.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7fe983b5e05e5227bb52a4924627b4c6164af2055ac21783dbe757c2b6acb27)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVerifiedAccessTrustProviderProps(
            policy_reference_name=policy_reference_name,
            trust_provider_type=trust_provider_type,
            description=description,
            device_options=device_options,
            device_trust_provider_type=device_trust_provider_type,
            oidc_options=oidc_options,
            sse_specification=sse_specification,
            tags=tags,
            user_trust_provider_type=user_trust_provider_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d88a304ffbbf17d299736418c1922495c74a433c9b30001e2bcbb69214df2f59)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f96a787f3339b7f6ca35766b655ece8f2f7b1c0c074bb60b12c38b5d98d97b07)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrCreationTime")
    def attr_creation_time(self) -> builtins.str:
        '''The creation time.

        :cloudformationAttribute: CreationTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrCreationTime"))

    @builtins.property
    @jsii.member(jsii_name="attrLastUpdatedTime")
    def attr_last_updated_time(self) -> builtins.str:
        '''The last updated time.

        :cloudformationAttribute: LastUpdatedTime
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrLastUpdatedTime"))

    @builtins.property
    @jsii.member(jsii_name="attrVerifiedAccessTrustProviderId")
    def attr_verified_access_trust_provider_id(self) -> builtins.str:
        '''The ID of the Verified Access trust provider.

        :cloudformationAttribute: VerifiedAccessTrustProviderId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVerifiedAccessTrustProviderId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="policyReferenceName")
    def policy_reference_name(self) -> builtins.str:
        '''The identifier to be used when working with policy rules.'''
        return typing.cast(builtins.str, jsii.get(self, "policyReferenceName"))

    @policy_reference_name.setter
    def policy_reference_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb2c31b98041aaf47d8cfe7a3c7ce8249f5ff0be19cc2c687c8cb1bccdfb16e1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyReferenceName", value)

    @builtins.property
    @jsii.member(jsii_name="trustProviderType")
    def trust_provider_type(self) -> builtins.str:
        '''The type of Verified Access trust provider.'''
        return typing.cast(builtins.str, jsii.get(self, "trustProviderType"))

    @trust_provider_type.setter
    def trust_provider_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45761c0ccd9af44abd6237ea9f2858300acdf7fa35301506907805ee92afe45e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "trustProviderType", value)

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access trust provider.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5596e28580f200cae9ee9d17544f728da33d5f8b120e97e5f75a7bcf6bd883f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value)

    @builtins.property
    @jsii.member(jsii_name="deviceOptions")
    def device_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.DeviceOptionsProperty"]]:
        '''The options for device-identity trust provider.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.DeviceOptionsProperty"]], jsii.get(self, "deviceOptions"))

    @device_options.setter
    def device_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.DeviceOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__58b5c20afb51f02a4dc38b9b3d77d6773ce2510a70f043f97eb9b86aba09fce7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deviceOptions", value)

    @builtins.property
    @jsii.member(jsii_name="deviceTrustProviderType")
    def device_trust_provider_type(self) -> typing.Optional[builtins.str]:
        '''The type of device-based trust provider.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deviceTrustProviderType"))

    @device_trust_provider_type.setter
    def device_trust_provider_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__86233e326be8a89b76683cacdc12855026065941b80a6573d40ec5ed9c51e1a7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "deviceTrustProviderType", value)

    @builtins.property
    @jsii.member(jsii_name="oidcOptions")
    def oidc_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.OidcOptionsProperty"]]:
        '''The options for an OpenID Connect-compatible user-identity trust provider.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.OidcOptionsProperty"]], jsii.get(self, "oidcOptions"))

    @oidc_options.setter
    def oidc_options(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.OidcOptionsProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3732e232bbcf8298bc1fd1eb5a3f0b56a229a30c2b1db74d6c78fcfc80e5e77)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "oidcOptions", value)

    @builtins.property
    @jsii.member(jsii_name="sseSpecification")
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.SseSpecificationProperty"]]:
        '''The options for additional server side encryption.'''
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.SseSpecificationProperty"]], jsii.get(self, "sseSpecification"))

    @sse_specification.setter
    def sse_specification(
        self,
        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnVerifiedAccessTrustProvider.SseSpecificationProperty"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__61dbb79cf6feff6860cc4e694ed7d715999903a77d202156b9297a946c1adfe5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sseSpecification", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b72cb8ed7ba887a1a566023a64d8bacd231d393400f4c30c557d902f1216443)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="userTrustProviderType")
    def user_trust_provider_type(self) -> typing.Optional[builtins.str]:
        '''The type of user-based trust provider.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "userTrustProviderType"))

    @user_trust_provider_type.setter
    def user_trust_provider_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4967d13842c9c8f34f254422ba9a304b8c052cdea0146ce880f1a5cc65ab27fb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "userTrustProviderType", value)

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessTrustProvider.DeviceOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "public_signing_key_url": "publicSigningKeyUrl",
            "tenant_id": "tenantId",
        },
    )
    class DeviceOptionsProperty:
        def __init__(
            self,
            *,
            public_signing_key_url: typing.Optional[builtins.str] = None,
            tenant_id: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the options for an AWS Verified Access device-identity based trust provider.

            :param public_signing_key_url: The URL AWS Verified Access will use to verify the authenticity of the device tokens.
            :param tenant_id: The ID of the tenant application with the device-identity provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-deviceoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                device_options_property = ec2.CfnVerifiedAccessTrustProvider.DeviceOptionsProperty(
                    public_signing_key_url="publicSigningKeyUrl",
                    tenant_id="tenantId"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__ff8d5f091c9e68a3470f9e83329b9ea9e8e9c3d69327e30f7c804de09801438f)
                check_type(argname="argument public_signing_key_url", value=public_signing_key_url, expected_type=type_hints["public_signing_key_url"])
                check_type(argname="argument tenant_id", value=tenant_id, expected_type=type_hints["tenant_id"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if public_signing_key_url is not None:
                self._values["public_signing_key_url"] = public_signing_key_url
            if tenant_id is not None:
                self._values["tenant_id"] = tenant_id

        @builtins.property
        def public_signing_key_url(self) -> typing.Optional[builtins.str]:
            '''The URL AWS Verified Access will use to verify the authenticity of the device tokens.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-deviceoptions.html#cfn-ec2-verifiedaccesstrustprovider-deviceoptions-publicsigningkeyurl
            '''
            result = self._values.get("public_signing_key_url")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def tenant_id(self) -> typing.Optional[builtins.str]:
            '''The ID of the tenant application with the device-identity provider.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-deviceoptions.html#cfn-ec2-verifiedaccesstrustprovider-deviceoptions-tenantid
            '''
            result = self._values.get("tenant_id")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "DeviceOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessTrustProvider.OidcOptionsProperty",
        jsii_struct_bases=[],
        name_mapping={
            "authorization_endpoint": "authorizationEndpoint",
            "client_id": "clientId",
            "client_secret": "clientSecret",
            "issuer": "issuer",
            "scope": "scope",
            "token_endpoint": "tokenEndpoint",
            "user_info_endpoint": "userInfoEndpoint",
        },
    )
    class OidcOptionsProperty:
        def __init__(
            self,
            *,
            authorization_endpoint: typing.Optional[builtins.str] = None,
            client_id: typing.Optional[builtins.str] = None,
            client_secret: typing.Optional[builtins.str] = None,
            issuer: typing.Optional[builtins.str] = None,
            scope: typing.Optional[builtins.str] = None,
            token_endpoint: typing.Optional[builtins.str] = None,
            user_info_endpoint: typing.Optional[builtins.str] = None,
        ) -> None:
            '''Describes the options for an OpenID Connect-compatible user-identity trust provider.

            :param authorization_endpoint: The OIDC authorization endpoint.
            :param client_id: The client identifier.
            :param client_secret: The client secret.
            :param issuer: The OIDC issuer.
            :param scope: The OpenID Connect (OIDC) scope specified.
            :param token_endpoint: The OIDC token endpoint.
            :param user_info_endpoint: The OIDC user info endpoint.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                oidc_options_property = ec2.CfnVerifiedAccessTrustProvider.OidcOptionsProperty(
                    authorization_endpoint="authorizationEndpoint",
                    client_id="clientId",
                    client_secret="clientSecret",
                    issuer="issuer",
                    scope="scope",
                    token_endpoint="tokenEndpoint",
                    user_info_endpoint="userInfoEndpoint"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__c7104c0ccee8d56cc5467c88b16f90245f04363672ad962c4ba9a01b66966498)
                check_type(argname="argument authorization_endpoint", value=authorization_endpoint, expected_type=type_hints["authorization_endpoint"])
                check_type(argname="argument client_id", value=client_id, expected_type=type_hints["client_id"])
                check_type(argname="argument client_secret", value=client_secret, expected_type=type_hints["client_secret"])
                check_type(argname="argument issuer", value=issuer, expected_type=type_hints["issuer"])
                check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
                check_type(argname="argument token_endpoint", value=token_endpoint, expected_type=type_hints["token_endpoint"])
                check_type(argname="argument user_info_endpoint", value=user_info_endpoint, expected_type=type_hints["user_info_endpoint"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if authorization_endpoint is not None:
                self._values["authorization_endpoint"] = authorization_endpoint
            if client_id is not None:
                self._values["client_id"] = client_id
            if client_secret is not None:
                self._values["client_secret"] = client_secret
            if issuer is not None:
                self._values["issuer"] = issuer
            if scope is not None:
                self._values["scope"] = scope
            if token_endpoint is not None:
                self._values["token_endpoint"] = token_endpoint
            if user_info_endpoint is not None:
                self._values["user_info_endpoint"] = user_info_endpoint

        @builtins.property
        def authorization_endpoint(self) -> typing.Optional[builtins.str]:
            '''The OIDC authorization endpoint.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-authorizationendpoint
            '''
            result = self._values.get("authorization_endpoint")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def client_id(self) -> typing.Optional[builtins.str]:
            '''The client identifier.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-clientid
            '''
            result = self._values.get("client_id")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def client_secret(self) -> typing.Optional[builtins.str]:
            '''The client secret.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-clientsecret
            '''
            result = self._values.get("client_secret")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def issuer(self) -> typing.Optional[builtins.str]:
            '''The OIDC issuer.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-issuer
            '''
            result = self._values.get("issuer")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def scope(self) -> typing.Optional[builtins.str]:
            '''The OpenID Connect (OIDC) scope specified.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-scope
            '''
            result = self._values.get("scope")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def token_endpoint(self) -> typing.Optional[builtins.str]:
            '''The OIDC token endpoint.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-tokenendpoint
            '''
            result = self._values.get("token_endpoint")
            return typing.cast(typing.Optional[builtins.str], result)

        @builtins.property
        def user_info_endpoint(self) -> typing.Optional[builtins.str]:
            '''The OIDC user info endpoint.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-oidcoptions.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions-userinfoendpoint
            '''
            result = self._values.get("user_info_endpoint")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "OidcOptionsProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )

    @jsii.data_type(
        jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessTrustProvider.SseSpecificationProperty",
        jsii_struct_bases=[],
        name_mapping={
            "customer_managed_key_enabled": "customerManagedKeyEnabled",
            "kms_key_arn": "kmsKeyArn",
        },
    )
    class SseSpecificationProperty:
        def __init__(
            self,
            *,
            customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
            kms_key_arn: typing.Optional[builtins.str] = None,
        ) -> None:
            '''AWS Verified Access provides server side encryption by default to data at rest using AWS -owned KMS keys.

            You also have the option of using customer managed KMS keys, which can be specified using the options below.

            :param customer_managed_key_enabled: Enable or disable the use of customer managed KMS keys for server side encryption. Valid values: ``True`` | ``False``
            :param kms_key_arn: The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-ssespecification.html
            :exampleMetadata: fixture=_generated

            Example::

                # The code below shows an example of how to instantiate this type.
                # The values are placeholders you should change.
                from aws_cdk import aws_ec2 as ec2
                
                sse_specification_property = ec2.CfnVerifiedAccessTrustProvider.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                )
            '''
            if __debug__:
                type_hints = typing.get_type_hints(_typecheckingstub__b6783e0e43d78c8311170a32417981320a95954dbab4be61dc06fd6f890dde1c)
                check_type(argname="argument customer_managed_key_enabled", value=customer_managed_key_enabled, expected_type=type_hints["customer_managed_key_enabled"])
                check_type(argname="argument kms_key_arn", value=kms_key_arn, expected_type=type_hints["kms_key_arn"])
            self._values: typing.Dict[builtins.str, typing.Any] = {}
            if customer_managed_key_enabled is not None:
                self._values["customer_managed_key_enabled"] = customer_managed_key_enabled
            if kms_key_arn is not None:
                self._values["kms_key_arn"] = kms_key_arn

        @builtins.property
        def customer_managed_key_enabled(
            self,
        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
            '''Enable or disable the use of customer managed KMS keys for server side encryption.

            Valid values: ``True`` | ``False``

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-ssespecification.html#cfn-ec2-verifiedaccesstrustprovider-ssespecification-customermanagedkeyenabled
            '''
            result = self._values.get("customer_managed_key_enabled")
            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

        @builtins.property
        def kms_key_arn(self) -> typing.Optional[builtins.str]:
            '''The ARN of the KMS key.

            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-verifiedaccesstrustprovider-ssespecification.html#cfn-ec2-verifiedaccesstrustprovider-ssespecification-kmskeyarn
            '''
            result = self._values.get("kms_key_arn")
            return typing.cast(typing.Optional[builtins.str], result)

        def __eq__(self, rhs: typing.Any) -> builtins.bool:
            return isinstance(rhs, self.__class__) and rhs._values == self._values

        def __ne__(self, rhs: typing.Any) -> builtins.bool:
            return not (rhs == self)

        def __repr__(self) -> str:
            return "SseSpecificationProperty(%s)" % ", ".join(
                k + "=" + repr(v) for k, v in self._values.items()
            )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVerifiedAccessTrustProviderProps",
    jsii_struct_bases=[],
    name_mapping={
        "policy_reference_name": "policyReferenceName",
        "trust_provider_type": "trustProviderType",
        "description": "description",
        "device_options": "deviceOptions",
        "device_trust_provider_type": "deviceTrustProviderType",
        "oidc_options": "oidcOptions",
        "sse_specification": "sseSpecification",
        "tags": "tags",
        "user_trust_provider_type": "userTrustProviderType",
    },
)
class CfnVerifiedAccessTrustProviderProps:
    def __init__(
        self,
        *,
        policy_reference_name: builtins.str,
        trust_provider_type: builtins.str,
        description: typing.Optional[builtins.str] = None,
        device_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.DeviceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        device_trust_provider_type: typing.Optional[builtins.str] = None,
        oidc_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.OidcOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        user_trust_provider_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVerifiedAccessTrustProvider``.

        :param policy_reference_name: The identifier to be used when working with policy rules.
        :param trust_provider_type: The type of Verified Access trust provider.
        :param description: A description for the AWS Verified Access trust provider.
        :param device_options: The options for device-identity trust provider.
        :param device_trust_provider_type: The type of device-based trust provider.
        :param oidc_options: The options for an OpenID Connect-compatible user-identity trust provider.
        :param sse_specification: The options for additional server side encryption.
        :param tags: The tags.
        :param user_trust_provider_type: The type of user-based trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_verified_access_trust_provider_props = ec2.CfnVerifiedAccessTrustProviderProps(
                policy_reference_name="policyReferenceName",
                trust_provider_type="trustProviderType",
            
                # the properties below are optional
                description="description",
                device_options=ec2.CfnVerifiedAccessTrustProvider.DeviceOptionsProperty(
                    public_signing_key_url="publicSigningKeyUrl",
                    tenant_id="tenantId"
                ),
                device_trust_provider_type="deviceTrustProviderType",
                oidc_options=ec2.CfnVerifiedAccessTrustProvider.OidcOptionsProperty(
                    authorization_endpoint="authorizationEndpoint",
                    client_id="clientId",
                    client_secret="clientSecret",
                    issuer="issuer",
                    scope="scope",
                    token_endpoint="tokenEndpoint",
                    user_info_endpoint="userInfoEndpoint"
                ),
                sse_specification=ec2.CfnVerifiedAccessTrustProvider.SseSpecificationProperty(
                    customer_managed_key_enabled=False,
                    kms_key_arn="kmsKeyArn"
                ),
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                user_trust_provider_type="userTrustProviderType"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a76a73a6fde22e9c9fa58fb20740e000e9153307f66b7f13cb4d7fe8bb6be7a9)
            check_type(argname="argument policy_reference_name", value=policy_reference_name, expected_type=type_hints["policy_reference_name"])
            check_type(argname="argument trust_provider_type", value=trust_provider_type, expected_type=type_hints["trust_provider_type"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument device_options", value=device_options, expected_type=type_hints["device_options"])
            check_type(argname="argument device_trust_provider_type", value=device_trust_provider_type, expected_type=type_hints["device_trust_provider_type"])
            check_type(argname="argument oidc_options", value=oidc_options, expected_type=type_hints["oidc_options"])
            check_type(argname="argument sse_specification", value=sse_specification, expected_type=type_hints["sse_specification"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument user_trust_provider_type", value=user_trust_provider_type, expected_type=type_hints["user_trust_provider_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "policy_reference_name": policy_reference_name,
            "trust_provider_type": trust_provider_type,
        }
        if description is not None:
            self._values["description"] = description
        if device_options is not None:
            self._values["device_options"] = device_options
        if device_trust_provider_type is not None:
            self._values["device_trust_provider_type"] = device_trust_provider_type
        if oidc_options is not None:
            self._values["oidc_options"] = oidc_options
        if sse_specification is not None:
            self._values["sse_specification"] = sse_specification
        if tags is not None:
            self._values["tags"] = tags
        if user_trust_provider_type is not None:
            self._values["user_trust_provider_type"] = user_trust_provider_type

    @builtins.property
    def policy_reference_name(self) -> builtins.str:
        '''The identifier to be used when working with policy rules.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-policyreferencename
        '''
        result = self._values.get("policy_reference_name")
        assert result is not None, "Required property 'policy_reference_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def trust_provider_type(self) -> builtins.str:
        '''The type of Verified Access trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-trustprovidertype
        '''
        result = self._values.get("trust_provider_type")
        assert result is not None, "Required property 'trust_provider_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description for the AWS Verified Access trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def device_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.DeviceOptionsProperty]]:
        '''The options for device-identity trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-deviceoptions
        '''
        result = self._values.get("device_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.DeviceOptionsProperty]], result)

    @builtins.property
    def device_trust_provider_type(self) -> typing.Optional[builtins.str]:
        '''The type of device-based trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-devicetrustprovidertype
        '''
        result = self._values.get("device_trust_provider_type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def oidc_options(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.OidcOptionsProperty]]:
        '''The options for an OpenID Connect-compatible user-identity trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-oidcoptions
        '''
        result = self._values.get("oidc_options")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.OidcOptionsProperty]], result)

    @builtins.property
    def sse_specification(
        self,
    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.SseSpecificationProperty]]:
        '''The options for additional server side encryption.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-ssespecification
        '''
        result = self._values.get("sse_specification")
        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.SseSpecificationProperty]], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def user_trust_provider_type(self) -> typing.Optional[builtins.str]:
        '''The type of user-based trust provider.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-verifiedaccesstrustprovider.html#cfn-ec2-verifiedaccesstrustprovider-usertrustprovidertype
        '''
        result = self._values.get("user_trust_provider_type")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVerifiedAccessTrustProviderProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
class CfnVolume(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVolume",
):
    '''Specifies an Amazon Elastic Block Store (Amazon EBS) volume.

    When you use AWS CloudFormation to update an Amazon EBS volume that modifies ``Iops`` , ``Size`` , or ``VolumeType`` , there is a cooldown period before another operation can occur. This can cause your stack to report being in ``UPDATE_IN_PROGRESS`` or ``UPDATE_ROLLBACK_IN_PROGRESS`` for long periods of time.

    Amazon EBS does not support sizing down an Amazon EBS volume. AWS CloudFormation does not attempt to modify an Amazon EBS volume to a smaller size on rollback.

    Some common scenarios when you might encounter a cooldown period for Amazon EBS include:

    - You successfully update an Amazon EBS volume and the update succeeds. When you attempt another update within the cooldown window, that update will be subject to a cooldown period.
    - You successfully update an Amazon EBS volume and the update succeeds but another change in your ``update-stack`` call fails. The rollback will be subject to a cooldown period.

    For more information on the cooldown period, see `Requirements when modifying volumes <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-volume-requirements.html>`_ .

    *DeletionPolicy attribute*

    To control how AWS CloudFormation handles the volume when the stack is deleted, set a deletion policy for your volume. You can choose to retain the volume, to delete the volume, or to create a snapshot of the volume. For more information, see `DeletionPolicy attribute <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html>`_ .
    .. epigraph::

       If you set a deletion policy that creates a snapshot, all tags on the volume are included in the snapshot.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
    :cloudformationResource: AWS::EC2::Volume
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_volume = ec2.CfnVolume(self, "MyCfnVolume",
            availability_zone="availabilityZone",
        
            # the properties below are optional
            auto_enable_io=False,
            encrypted=False,
            iops=123,
            kms_key_id="kmsKeyId",
            multi_attach_enabled=False,
            outpost_arn="outpostArn",
            size=123,
            snapshot_id="snapshotId",
            tags=[CfnTag(
                key="key",
                value="value"
            )],
            throughput=123,
            volume_type="volumeType"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        auto_enable_io: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        iops: typing.Optional[jsii.Number] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        multi_attach_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
        size: typing.Optional[jsii.Number] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        throughput: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param availability_zone: The ID of the Availability Zone in which to create the volume. For example, ``us-east-1a`` .
        :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.
        :param encrypted: Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the *Amazon Elastic Compute Cloud User Guide* . Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ .
        :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000 - 16,000 IOPS - ``io1`` : 100 - 64,000 IOPS - ``io2`` : 100 - 256,000 IOPS For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS. This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS. This parameter is not supported for ``gp2`` , ``st1`` , ``sc1`` , or ``standard`` volumes.
        :param kms_key_id: The identifier of the AWS KMS key to use for Amazon EBS encryption. If ``KmsKeyId`` is specified, the encrypted state must be ``true`` . If you omit this property and your account is enabled for encryption by default, or *Encrypted* is set to ``true`` , then the volume is encrypted using the default key specified for your account. If your account does not have a default key, then the volume is encrypted using the AWS managed key . Alternatively, if you want to specify a different key, you can specify one of the following: - Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab. - Key alias. Specify the alias for the key, prefixed with ``alias/`` . For example, for a key with the alias ``my_cmk`` , use ``alias/my_cmk`` . Or to specify the AWS managed key , use ``alias/aws/ebs`` . - Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab. - Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.
        :param multi_attach_enabled: Indicates whether Amazon EBS Multi-Attach is enabled. AWS CloudFormation does not currently support updating a single-attach volume to be multi-attach enabled, updating a multi-attach enabled volume to be single-attach, or updating the size or number of I/O operations per second (IOPS) of a multi-attach enabled volume.
        :param outpost_arn: The Amazon Resource Name (ARN) of the Outpost.
        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size. The following are the supported volumes sizes for each volume type: - ``gp2`` and ``gp3`` : 1 - 16,384 GiB - ``io1`` : 4 - 16,384 GiB - ``io2`` : 4 - 65,536 GiB - ``st1`` and ``sc1`` : 125 - 16,384 GiB - ``standard`` : 1 - 1024 GiB
        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size.
        :param tags: The tags to apply to the volume during creation.
        :param throughput: The throughput to provision for a volume, with a maximum of 1,000 MiB/s. This parameter is valid only for ``gp3`` volumes. The default value is 125. Valid Range: Minimum value of 125. Maximum value of 1000.
        :param volume_type: The volume type. This parameter can be one of the following values:. - General Purpose SSD: ``gp2`` | ``gp3`` - Provisioned IOPS SSD: ``io1`` | ``io2`` - Throughput Optimized HDD: ``st1`` - Cold HDD: ``sc1`` - Magnetic: ``standard`` For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . Default: ``gp2``
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__915a70f35b9237e059cd8fc78c5da31e1d4f2476ed4857c7ac173e559447905e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVolumeProps(
            availability_zone=availability_zone,
            auto_enable_io=auto_enable_io,
            encrypted=encrypted,
            iops=iops,
            kms_key_id=kms_key_id,
            multi_attach_enabled=multi_attach_enabled,
            outpost_arn=outpost_arn,
            size=size,
            snapshot_id=snapshot_id,
            tags=tags,
            throughput=throughput,
            volume_type=volume_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2a2f83998f9a1f05fc7aa51cad422fc8991c204c3bd4a1497c7ad336226ccfb)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f774e878be0007be0abcd6c15b4c68663fb4b630b89e8ca74b84808f2dc4266e)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="attrVolumeId")
    def attr_volume_id(self) -> builtins.str:
        '''The ID of the volume.

        :cloudformationAttribute: VolumeId
        '''
        return typing.cast(builtins.str, jsii.get(self, "attrVolumeId"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def tags(self) -> _TagManager_0a598cb3:
        '''Tag Manager which manages the tags for this resource.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The ID of the Availability Zone in which to create the volume.'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @availability_zone.setter
    def availability_zone(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d1b84d91c4e8cd76822b48ed0343301ddd2a721e24f40035f18674528e6a7b7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "availabilityZone", value)

    @builtins.property
    @jsii.member(jsii_name="autoEnableIo")
    def auto_enable_io(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the volume is auto-enabled for I/O operations.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "autoEnableIo"))

    @auto_enable_io.setter
    def auto_enable_io(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fdc1847dc310b2a1577e5dcdebe88b86b9758cb785d226da14643575f9ed8bd8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "autoEnableIo", value)

    @builtins.property
    @jsii.member(jsii_name="encrypted")
    def encrypted(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the volume should be encrypted.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "encrypted"))

    @encrypted.setter
    def encrypted(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a0dab307ba7c618b3a2a8af0cf29a1e9133b8702661f57ee95de967a6735ab24)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "encrypted", value)

    @builtins.property
    @jsii.member(jsii_name="iops")
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS).'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "iops"))

    @iops.setter
    def iops(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__807a1d840cc3d255028247a06a6ef15c200d09e79136ebf2009053f8b69ffd1a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "iops", value)

    @builtins.property
    @jsii.member(jsii_name="kmsKeyId")
    def kms_key_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the AWS KMS key to use for Amazon EBS encryption.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "kmsKeyId"))

    @kms_key_id.setter
    def kms_key_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a031a395aedeac6fb43372966648e605034195c39adf3a5eb5d79fca8a2e05eb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "kmsKeyId", value)

    @builtins.property
    @jsii.member(jsii_name="multiAttachEnabled")
    def multi_attach_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether Amazon EBS Multi-Attach is enabled.'''
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "multiAttachEnabled"))

    @multi_attach_enabled.setter
    def multi_attach_enabled(
        self,
        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e2e4bb0974e2a111c4cb4e3d395830b7cc54aeeb30dbb46934b3474e9b56460)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "multiAttachEnabled", value)

    @builtins.property
    @jsii.member(jsii_name="outpostArn")
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "outpostArn"))

    @outpost_arn.setter
    def outpost_arn(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0ef1cb0e21c5581e1fbbd559f33ec33f532d3ab32f1d04856178952abecd54dd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "outpostArn", value)

    @builtins.property
    @jsii.member(jsii_name="size")
    def size(self) -> typing.Optional[jsii.Number]:
        '''The size of the volume, in GiBs.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "size"))

    @size.setter
    def size(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b612fe5742ad859f2f5b61d73e008fc633f66ed6eccf5d3ab41d6dc2403b7844)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "size", value)

    @builtins.property
    @jsii.member(jsii_name="snapshotId")
    def snapshot_id(self) -> typing.Optional[builtins.str]:
        '''The snapshot from which to create the volume.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "snapshotId"))

    @snapshot_id.setter
    def snapshot_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__62fabf6e3c9fe7c72a6b24dfb7236158ddc7f0739372217b4cd7c02809a327cd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "snapshotId", value)

    @builtins.property
    @jsii.member(jsii_name="tagsRaw")
    def tags_raw(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the volume during creation.'''
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tagsRaw"))

    @tags_raw.setter
    def tags_raw(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2492a2a8e711d8a4ec13f5ac387221ec25b8844eb318d76f2f9913a44d0e80a1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tagsRaw", value)

    @builtins.property
    @jsii.member(jsii_name="throughput")
    def throughput(self) -> typing.Optional[jsii.Number]:
        '''The throughput to provision for a volume, with a maximum of 1,000 MiB/s.'''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "throughput"))

    @throughput.setter
    def throughput(self, value: typing.Optional[jsii.Number]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52b794f14acdf16af1459720ad364d41f271215d47cf0e4717dd83ce005e4b69)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "throughput", value)

    @builtins.property
    @jsii.member(jsii_name="volumeType")
    def volume_type(self) -> typing.Optional[builtins.str]:
        '''The volume type.

        This parameter can be one of the following values:.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "volumeType"))

    @volume_type.setter
    def volume_type(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45764f3b57b9177d923e13cf91fbc29ed9c80eeebc001d4bd7c1600d28437ee6)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "volumeType", value)


@jsii.implements(_IInspectable_c2943556)
class CfnVolumeAttachment(
    _CfnResource_9df397a6,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CfnVolumeAttachment",
):
    '''Attaches an Amazon EBS volume to a running instance and exposes it to the instance with the specified device name.

    Before this resource can be deleted (and therefore the volume detached), you must first unmount the volume in the instance. Failure to do so results in the volume being stuck in the busy state while it is trying to detach, which could possibly damage the file system or the data it contains.

    If an Amazon EBS volume is the root device of an instance, it cannot be detached while the instance is in the "running" state. To detach the root volume, stop the instance first.

    If the root volume is detached from an instance with an AWS Marketplace product code, then the product codes from that volume are no longer associated with the instance.

    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volumeattachment.html
    :cloudformationResource: AWS::EC2::VolumeAttachment
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        cfn_volume_attachment = ec2.CfnVolumeAttachment(self, "MyCfnVolumeAttachment",
            instance_id="instanceId",
            volume_id="volumeId",
        
            # the properties below are optional
            device="device"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        instance_id: builtins.str,
        volume_id: builtins.str,
        device: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: Scope in which this resource is defined.
        :param id: Construct identifier for this resource (unique in its scope).
        :param instance_id: The ID of the instance to which the volume attaches. This value can be a reference to an ```AWS::EC2::Instance`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource, or it can be the physical ID of an existing EC2 instance.
        :param volume_id: The ID of the Amazon EBS volume. The volume and instance must be within the same Availability Zone. This value can be a reference to an ```AWS::EC2::Volume`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ebs-volume.html>`_ resource, or it can be the volume ID of an existing Amazon EBS volume.
        :param device: The device name (for example, ``/dev/sdh`` or ``xvdh`` ).
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f91e3af459fd3c08f3e864b943d726fa098088641452489ce64fb32280c6e8d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CfnVolumeAttachmentProps(
            instance_id=instance_id, volume_id=volume_id, device=device
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="inspect")
    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
        '''Examines the CloudFormation resource and discloses attributes.

        :param inspector: tree inspector to collect and process attributes.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c3fecb972815426281f672313569cdcfa38b276801c82a6aad225ecc33f44424)
            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))

    @jsii.member(jsii_name="renderProperties")
    def _render_properties(
        self,
        props: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''
        :param props: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb30c7c03599c59990efcdf751a9418ed9f6c6ca586614259701e1efb0f26a25)
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
        '''The CloudFormation resource type name for this resource class.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))

    @builtins.property
    @jsii.member(jsii_name="cfnProperties")
    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The ID of the instance to which the volume attaches.'''
        return typing.cast(builtins.str, jsii.get(self, "instanceId"))

    @instance_id.setter
    def instance_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dac7c5a8973cffe34d524c311d935f23aa495f0cd2b578e4f86ad9f0c407492c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instanceId", value)

    @builtins.property
    @jsii.member(jsii_name="volumeId")
    def volume_id(self) -> builtins.str:
        '''The ID of the Amazon EBS volume.'''
        return typing.cast(builtins.str, jsii.get(self, "volumeId"))

    @volume_id.setter
    def volume_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__beb3c2d5f9b7dbc507ec75d698c4aaa10e1a2d6c151eaaabd7b8983704434b1d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "volumeId", value)

    @builtins.property
    @jsii.member(jsii_name="device")
    def device(self) -> typing.Optional[builtins.str]:
        '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "device"))

    @device.setter
    def device(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb607912a28c459177794348b3a0d3c1a5dec52861d12a3350f8cbd1748e4985)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "device", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVolumeAttachmentProps",
    jsii_struct_bases=[],
    name_mapping={
        "instance_id": "instanceId",
        "volume_id": "volumeId",
        "device": "device",
    },
)
class CfnVolumeAttachmentProps:
    def __init__(
        self,
        *,
        instance_id: builtins.str,
        volume_id: builtins.str,
        device: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVolumeAttachment``.

        :param instance_id: The ID of the instance to which the volume attaches. This value can be a reference to an ```AWS::EC2::Instance`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource, or it can be the physical ID of an existing EC2 instance.
        :param volume_id: The ID of the Amazon EBS volume. The volume and instance must be within the same Availability Zone. This value can be a reference to an ```AWS::EC2::Volume`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ebs-volume.html>`_ resource, or it can be the volume ID of an existing Amazon EBS volume.
        :param device: The device name (for example, ``/dev/sdh`` or ``xvdh`` ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volumeattachment.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_volume_attachment_props = ec2.CfnVolumeAttachmentProps(
                instance_id="instanceId",
                volume_id="volumeId",
            
                # the properties below are optional
                device="device"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6271dcebfee0c630e1316ce2182ab20ce3a7666c38f1a8e7d0c5d8226de8479f)
            check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
            check_type(argname="argument volume_id", value=volume_id, expected_type=type_hints["volume_id"])
            check_type(argname="argument device", value=device, expected_type=type_hints["device"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance_id": instance_id,
            "volume_id": volume_id,
        }
        if device is not None:
            self._values["device"] = device

    @builtins.property
    def instance_id(self) -> builtins.str:
        '''The ID of the instance to which the volume attaches.

        This value can be a reference to an ```AWS::EC2::Instance`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html>`_ resource, or it can be the physical ID of an existing EC2 instance.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volumeattachment.html#cfn-ec2-volumeattachment-instanceid
        '''
        result = self._values.get("instance_id")
        assert result is not None, "Required property 'instance_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def volume_id(self) -> builtins.str:
        '''The ID of the Amazon EBS volume.

        The volume and instance must be within the same Availability Zone. This value can be a reference to an ```AWS::EC2::Volume`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ebs-volume.html>`_ resource, or it can be the volume ID of an existing Amazon EBS volume.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volumeattachment.html#cfn-ec2-volumeattachment-volumeid
        '''
        result = self._values.get("volume_id")
        assert result is not None, "Required property 'volume_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def device(self) -> typing.Optional[builtins.str]:
        '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volumeattachment.html#cfn-ec2-volumeattachment-device
        '''
        result = self._values.get("device")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVolumeAttachmentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CfnVolumeProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "auto_enable_io": "autoEnableIo",
        "encrypted": "encrypted",
        "iops": "iops",
        "kms_key_id": "kmsKeyId",
        "multi_attach_enabled": "multiAttachEnabled",
        "outpost_arn": "outpostArn",
        "size": "size",
        "snapshot_id": "snapshotId",
        "tags": "tags",
        "throughput": "throughput",
        "volume_type": "volumeType",
    },
)
class CfnVolumeProps:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        auto_enable_io: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        iops: typing.Optional[jsii.Number] = None,
        kms_key_id: typing.Optional[builtins.str] = None,
        multi_attach_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
        outpost_arn: typing.Optional[builtins.str] = None,
        size: typing.Optional[jsii.Number] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
        throughput: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for defining a ``CfnVolume``.

        :param availability_zone: The ID of the Availability Zone in which to create the volume. For example, ``us-east-1a`` .
        :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.
        :param encrypted: Indicates whether the volume should be encrypted. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the *Amazon Elastic Compute Cloud User Guide* . Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ .
        :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000 - 16,000 IOPS - ``io1`` : 100 - 64,000 IOPS - ``io2`` : 100 - 256,000 IOPS For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS. This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS. This parameter is not supported for ``gp2`` , ``st1`` , ``sc1`` , or ``standard`` volumes.
        :param kms_key_id: The identifier of the AWS KMS key to use for Amazon EBS encryption. If ``KmsKeyId`` is specified, the encrypted state must be ``true`` . If you omit this property and your account is enabled for encryption by default, or *Encrypted* is set to ``true`` , then the volume is encrypted using the default key specified for your account. If your account does not have a default key, then the volume is encrypted using the AWS managed key . Alternatively, if you want to specify a different key, you can specify one of the following: - Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab. - Key alias. Specify the alias for the key, prefixed with ``alias/`` . For example, for a key with the alias ``my_cmk`` , use ``alias/my_cmk`` . Or to specify the AWS managed key , use ``alias/aws/ebs`` . - Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab. - Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.
        :param multi_attach_enabled: Indicates whether Amazon EBS Multi-Attach is enabled. AWS CloudFormation does not currently support updating a single-attach volume to be multi-attach enabled, updating a multi-attach enabled volume to be single-attach, or updating the size or number of I/O operations per second (IOPS) of a multi-attach enabled volume.
        :param outpost_arn: The Amazon Resource Name (ARN) of the Outpost.
        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size. The following are the supported volumes sizes for each volume type: - ``gp2`` and ``gp3`` : 1 - 16,384 GiB - ``io1`` : 4 - 16,384 GiB - ``io2`` : 4 - 65,536 GiB - ``st1`` and ``sc1`` : 125 - 16,384 GiB - ``standard`` : 1 - 1024 GiB
        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size.
        :param tags: The tags to apply to the volume during creation.
        :param throughput: The throughput to provision for a volume, with a maximum of 1,000 MiB/s. This parameter is valid only for ``gp3`` volumes. The default value is 125. Valid Range: Minimum value of 125. Maximum value of 1000.
        :param volume_type: The volume type. This parameter can be one of the following values:. - General Purpose SSD: ``gp2`` | ``gp3`` - Provisioned IOPS SSD: ``io1`` | ``io2`` - Throughput Optimized HDD: ``st1`` - Cold HDD: ``sc1`` - Magnetic: ``standard`` For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . Default: ``gp2``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            cfn_volume_props = ec2.CfnVolumeProps(
                availability_zone="availabilityZone",
            
                # the properties below are optional
                auto_enable_io=False,
                encrypted=False,
                iops=123,
                kms_key_id="kmsKeyId",
                multi_attach_enabled=False,
                outpost_arn="outpostArn",
                size=123,
                snapshot_id="snapshotId",
                tags=[CfnTag(
                    key="key",
                    value="value"
                )],
                throughput=123,
                volume_type="volumeType"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__df1f84bfc2d41a9f2d283d6a706150686c01c8f45a742c92af54cbee7bc75f3d)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument auto_enable_io", value=auto_enable_io, expected_type=type_hints["auto_enable_io"])
            check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
            check_type(argname="argument multi_attach_enabled", value=multi_attach_enabled, expected_type=type_hints["multi_attach_enabled"])
            check_type(argname="argument outpost_arn", value=outpost_arn, expected_type=type_hints["outpost_arn"])
            check_type(argname="argument size", value=size, expected_type=type_hints["size"])
            check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
        }
        if auto_enable_io is not None:
            self._values["auto_enable_io"] = auto_enable_io
        if encrypted is not None:
            self._values["encrypted"] = encrypted
        if iops is not None:
            self._values["iops"] = iops
        if kms_key_id is not None:
            self._values["kms_key_id"] = kms_key_id
        if multi_attach_enabled is not None:
            self._values["multi_attach_enabled"] = multi_attach_enabled
        if outpost_arn is not None:
            self._values["outpost_arn"] = outpost_arn
        if size is not None:
            self._values["size"] = size
        if snapshot_id is not None:
            self._values["snapshot_id"] = snapshot_id
        if tags is not None:
            self._values["tags"] = tags
        if throughput is not None:
            self._values["throughput"] = throughput
        if volume_type is not None:
            self._values["volume_type"] = volume_type

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The ID of the Availability Zone in which to create the volume.

        For example, ``us-east-1a`` .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-availabilityzone
        '''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def auto_enable_io(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the volume is auto-enabled for I/O operations.

        By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-autoenableio
        '''
        result = self._values.get("auto_enable_io")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def encrypted(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether the volume should be encrypted.

        The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the *Amazon Elastic Compute Cloud User Guide* .

        Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_ .

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-encrypted
        '''
        result = self._values.get("encrypted")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS).

        For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.

        The following are the supported values for each volume type:

        - ``gp3`` : 3,000 - 16,000 IOPS
        - ``io1`` : 100 - 64,000 IOPS
        - ``io2`` : 100 - 256,000 IOPS

        For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS.

        This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS. This parameter is not supported for ``gp2`` , ``st1`` , ``sc1`` , or ``standard`` volumes.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-iops
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def kms_key_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the AWS KMS key to use for Amazon EBS encryption.

        If ``KmsKeyId`` is specified, the encrypted state must be ``true`` .

        If you omit this property and your account is enabled for encryption by default, or *Encrypted* is set to ``true`` , then the volume is encrypted using the default key specified for your account. If your account does not have a default key, then the volume is encrypted using the AWS managed key .

        Alternatively, if you want to specify a different key, you can specify one of the following:

        - Key ID. For example, 1234abcd-12ab-34cd-56ef-1234567890ab.
        - Key alias. Specify the alias for the key, prefixed with ``alias/`` . For example, for a key with the alias ``my_cmk`` , use ``alias/my_cmk`` . Or to specify the AWS managed key , use ``alias/aws/ebs`` .
        - Key ARN. For example, arn:aws:kms:us-east-1:012345678910:key/1234abcd-12ab-34cd-56ef-1234567890ab.
        - Alias ARN. For example, arn:aws:kms:us-east-1:012345678910:alias/ExampleAlias.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-kmskeyid
        '''
        result = self._values.get("kms_key_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def multi_attach_enabled(
        self,
    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
        '''Indicates whether Amazon EBS Multi-Attach is enabled.

        AWS CloudFormation does not currently support updating a single-attach volume to be multi-attach enabled, updating a multi-attach enabled volume to be single-attach, or updating the size or number of I/O operations per second (IOPS) of a multi-attach enabled volume.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-multiattachenabled
        '''
        result = self._values.get("multi_attach_enabled")
        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)

    @builtins.property
    def outpost_arn(self) -> typing.Optional[builtins.str]:
        '''The Amazon Resource Name (ARN) of the Outpost.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-outpostarn
        '''
        result = self._values.get("outpost_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def size(self) -> typing.Optional[jsii.Number]:
        '''The size of the volume, in GiBs.

        You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size.

        The following are the supported volumes sizes for each volume type:

        - ``gp2`` and ``gp3`` : 1 - 16,384 GiB
        - ``io1`` : 4 - 16,384 GiB
        - ``io2`` : 4 - 65,536 GiB
        - ``st1`` and ``sc1`` : 125 - 16,384 GiB
        - ``standard`` : 1 - 1024 GiB

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-size
        '''
        result = self._values.get("size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def snapshot_id(self) -> typing.Optional[builtins.str]:
        '''The snapshot from which to create the volume.

        You must specify either a snapshot ID or a volume size.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-snapshotid
        '''
        result = self._values.get("snapshot_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
        '''The tags to apply to the volume during creation.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)

    @builtins.property
    def throughput(self) -> typing.Optional[jsii.Number]:
        '''The throughput to provision for a volume, with a maximum of 1,000 MiB/s.

        This parameter is valid only for ``gp3`` volumes. The default value is 125.

        Valid Range: Minimum value of 125. Maximum value of 1000.

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-throughput
        '''
        result = self._values.get("throughput")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_type(self) -> typing.Optional[builtins.str]:
        '''The volume type. This parameter can be one of the following values:.

        - General Purpose SSD: ``gp2`` | ``gp3``
        - Provisioned IOPS SSD: ``io1`` | ``io2``
        - Throughput Optimized HDD: ``st1``
        - Cold HDD: ``sc1``
        - Magnetic: ``standard``

        For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>`_ in the *Amazon Elastic Compute Cloud User Guide* .

        Default: ``gp2``

        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-volumetype
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CfnVolumeProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ClientVpnAuthorizationRule(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnAuthorizationRule",
):
    '''A client VPN authorization rule.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # client_vpn_endpoint: ec2.ClientVpnEndpoint
        
        client_vpn_authorization_rule = ec2.ClientVpnAuthorizationRule(self, "MyClientVpnAuthorizationRule",
            cidr="cidr",
        
            # the properties below are optional
            client_vpn_endpoint=client_vpn_endpoint,
            description="description",
            group_id="groupId"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        client_vpn_endpoint: typing.Optional["IClientVpnEndpoint"] = None,
        cidr: builtins.str,
        description: typing.Optional[builtins.str] = None,
        group_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param client_vpn_endpoint: The client VPN endpoint to which to add the rule. Default: clientVpnEndpoint is required
        :param cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param description: A brief description of the authorization rule. Default: - no description
        :param group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Default: - authorize all groups
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6f8556471b9878ffc0a31155bd24890dd137dc2f25f5faa23ec8adbfb35154db)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ClientVpnAuthorizationRuleProps(
            client_vpn_endpoint=client_vpn_endpoint,
            cidr=cidr,
            description=description,
            group_id=group_id,
        )

        jsii.create(self.__class__, self, [scope, id, props])


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnAuthorizationRuleOptions",
    jsii_struct_bases=[],
    name_mapping={"cidr": "cidr", "description": "description", "group_id": "groupId"},
)
class ClientVpnAuthorizationRuleOptions:
    def __init__(
        self,
        *,
        cidr: builtins.str,
        description: typing.Optional[builtins.str] = None,
        group_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options for a ClientVpnAuthorizationRule.

        :param cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param description: A brief description of the authorization rule. Default: - no description
        :param group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Default: - authorize all groups

        :exampleMetadata: fixture=client-vpn infused

        Example::

            endpoint = vpc.add_client_vpn_endpoint("Endpoint",
                cidr="10.100.0.0/16",
                server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
                user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider),
                authorize_all_users_to_vpc_cidr=False
            )
            
            endpoint.add_authorization_rule("Rule",
                cidr="10.0.10.0/32",
                group_id="group-id"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fc07ac4ea1a45fb240bfaf16763919c7856484bb210d9dea034d4beb7c00495b)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
        }
        if description is not None:
            self._values["description"] = description
        if group_id is not None:
            self._values["group_id"] = group_id

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the network for which access is being authorized.'''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group.

        :default: - authorize all groups
        '''
        result = self._values.get("group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnAuthorizationRuleOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnAuthorizationRuleProps",
    jsii_struct_bases=[ClientVpnAuthorizationRuleOptions],
    name_mapping={
        "cidr": "cidr",
        "description": "description",
        "group_id": "groupId",
        "client_vpn_endpoint": "clientVpnEndpoint",
    },
)
class ClientVpnAuthorizationRuleProps(ClientVpnAuthorizationRuleOptions):
    def __init__(
        self,
        *,
        cidr: builtins.str,
        description: typing.Optional[builtins.str] = None,
        group_id: typing.Optional[builtins.str] = None,
        client_vpn_endpoint: typing.Optional["IClientVpnEndpoint"] = None,
    ) -> None:
        '''Properties for a ClientVpnAuthorizationRule.

        :param cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param description: A brief description of the authorization rule. Default: - no description
        :param group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Default: - authorize all groups
        :param client_vpn_endpoint: The client VPN endpoint to which to add the rule. Default: clientVpnEndpoint is required

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # client_vpn_endpoint: ec2.ClientVpnEndpoint
            
            client_vpn_authorization_rule_props = ec2.ClientVpnAuthorizationRuleProps(
                cidr="cidr",
            
                # the properties below are optional
                client_vpn_endpoint=client_vpn_endpoint,
                description="description",
                group_id="groupId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__70f178e990e98988f4f5a0c35f7e79848b474cc9f47c2cc007d2c2694316927d)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
            check_type(argname="argument client_vpn_endpoint", value=client_vpn_endpoint, expected_type=type_hints["client_vpn_endpoint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
        }
        if description is not None:
            self._values["description"] = description
        if group_id is not None:
            self._values["group_id"] = group_id
        if client_vpn_endpoint is not None:
            self._values["client_vpn_endpoint"] = client_vpn_endpoint

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the network for which access is being authorized.'''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def group_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group.

        :default: - authorize all groups
        '''
        result = self._values.get("group_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_vpn_endpoint(self) -> typing.Optional["IClientVpnEndpoint"]:
        '''The client VPN endpoint to which to add the rule.

        :default: clientVpnEndpoint is required
        '''
        result = self._values.get("client_vpn_endpoint")
        return typing.cast(typing.Optional["IClientVpnEndpoint"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnAuthorizationRuleProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnEndpointAttributes",
    jsii_struct_bases=[],
    name_mapping={"endpoint_id": "endpointId", "security_groups": "securityGroups"},
)
class ClientVpnEndpointAttributes:
    def __init__(
        self,
        *,
        endpoint_id: builtins.str,
        security_groups: typing.Sequence["ISecurityGroup"],
    ) -> None:
        '''Attributes when importing an existing client VPN endpoint.

        :param endpoint_id: The endpoint ID.
        :param security_groups: The security groups associated with the endpoint.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # security_group: ec2.SecurityGroup
            
            client_vpn_endpoint_attributes = ec2.ClientVpnEndpointAttributes(
                endpoint_id="endpointId",
                security_groups=[security_group]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6321df916114580e1b10f3608ccf6ea302a3a8abe3ed6fe5a06f37024b167c26)
            check_type(argname="argument endpoint_id", value=endpoint_id, expected_type=type_hints["endpoint_id"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "endpoint_id": endpoint_id,
            "security_groups": security_groups,
        }

    @builtins.property
    def endpoint_id(self) -> builtins.str:
        '''The endpoint ID.'''
        result = self._values.get("endpoint_id")
        assert result is not None, "Required property 'endpoint_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def security_groups(self) -> typing.List["ISecurityGroup"]:
        '''The security groups associated with the endpoint.'''
        result = self._values.get("security_groups")
        assert result is not None, "Required property 'security_groups' is missing"
        return typing.cast(typing.List["ISecurityGroup"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnEndpointAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnEndpointOptions",
    jsii_struct_bases=[],
    name_mapping={
        "cidr": "cidr",
        "server_certificate_arn": "serverCertificateArn",
        "authorize_all_users_to_vpc_cidr": "authorizeAllUsersToVpcCidr",
        "client_certificate_arn": "clientCertificateArn",
        "client_connection_handler": "clientConnectionHandler",
        "client_login_banner": "clientLoginBanner",
        "description": "description",
        "dns_servers": "dnsServers",
        "logging": "logging",
        "log_group": "logGroup",
        "log_stream": "logStream",
        "port": "port",
        "security_groups": "securityGroups",
        "self_service_portal": "selfServicePortal",
        "session_timeout": "sessionTimeout",
        "split_tunnel": "splitTunnel",
        "transport_protocol": "transportProtocol",
        "user_based_authentication": "userBasedAuthentication",
        "vpc_subnets": "vpcSubnets",
    },
)
class ClientVpnEndpointOptions:
    def __init__(
        self,
        *,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional["IClientVpnConnectionHandler"] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional["VpnPort"] = None,
        security_groups: typing.Optional[typing.Sequence["ISecurityGroup"]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional["ClientVpnSessionTimeout"] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional["TransportProtocol"] = None,
        user_based_authentication: typing.Optional["ClientVpnUserBasedAuthentication"] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Options for a client VPN endpoint.

        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy

        :exampleMetadata: fixture=client-vpn infused

        Example::

            endpoint = vpc.add_client_vpn_endpoint("Endpoint",
                cidr="10.100.0.0/16",
                server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
                user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider),
                authorize_all_users_to_vpc_cidr=False
            )
            
            endpoint.add_authorization_rule("Rule",
                cidr="10.0.10.0/32",
                group_id="group-id"
            )
        '''
        if isinstance(vpc_subnets, dict):
            vpc_subnets = SubnetSelection(**vpc_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__73f8593e2e6199f8ae542cff4cbe02f0be09fd9043b8072cbb652d5b05d44687)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument server_certificate_arn", value=server_certificate_arn, expected_type=type_hints["server_certificate_arn"])
            check_type(argname="argument authorize_all_users_to_vpc_cidr", value=authorize_all_users_to_vpc_cidr, expected_type=type_hints["authorize_all_users_to_vpc_cidr"])
            check_type(argname="argument client_certificate_arn", value=client_certificate_arn, expected_type=type_hints["client_certificate_arn"])
            check_type(argname="argument client_connection_handler", value=client_connection_handler, expected_type=type_hints["client_connection_handler"])
            check_type(argname="argument client_login_banner", value=client_login_banner, expected_type=type_hints["client_login_banner"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument dns_servers", value=dns_servers, expected_type=type_hints["dns_servers"])
            check_type(argname="argument logging", value=logging, expected_type=type_hints["logging"])
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            check_type(argname="argument log_stream", value=log_stream, expected_type=type_hints["log_stream"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument self_service_portal", value=self_service_portal, expected_type=type_hints["self_service_portal"])
            check_type(argname="argument session_timeout", value=session_timeout, expected_type=type_hints["session_timeout"])
            check_type(argname="argument split_tunnel", value=split_tunnel, expected_type=type_hints["split_tunnel"])
            check_type(argname="argument transport_protocol", value=transport_protocol, expected_type=type_hints["transport_protocol"])
            check_type(argname="argument user_based_authentication", value=user_based_authentication, expected_type=type_hints["user_based_authentication"])
            check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "server_certificate_arn": server_certificate_arn,
        }
        if authorize_all_users_to_vpc_cidr is not None:
            self._values["authorize_all_users_to_vpc_cidr"] = authorize_all_users_to_vpc_cidr
        if client_certificate_arn is not None:
            self._values["client_certificate_arn"] = client_certificate_arn
        if client_connection_handler is not None:
            self._values["client_connection_handler"] = client_connection_handler
        if client_login_banner is not None:
            self._values["client_login_banner"] = client_login_banner
        if description is not None:
            self._values["description"] = description
        if dns_servers is not None:
            self._values["dns_servers"] = dns_servers
        if logging is not None:
            self._values["logging"] = logging
        if log_group is not None:
            self._values["log_group"] = log_group
        if log_stream is not None:
            self._values["log_stream"] = log_stream
        if port is not None:
            self._values["port"] = port
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if self_service_portal is not None:
            self._values["self_service_portal"] = self_service_portal
        if session_timeout is not None:
            self._values["session_timeout"] = session_timeout
        if split_tunnel is not None:
            self._values["split_tunnel"] = split_tunnel
        if transport_protocol is not None:
            self._values["transport_protocol"] = transport_protocol
        if user_based_authentication is not None:
            self._values["user_based_authentication"] = user_based_authentication
        if vpc_subnets is not None:
            self._values["vpc_subnets"] = vpc_subnets

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, from which to assign client IP addresses.

        The address range cannot overlap with the local CIDR of the VPC
        in which the associated subnet is located, or the routes that you add manually.

        Changing the address range will replace the Client VPN endpoint.

        The CIDR block should be /22 or greater.
        '''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def server_certificate_arn(self) -> builtins.str:
        '''The ARN of the server certificate.'''
        result = self._values.get("server_certificate_arn")
        assert result is not None, "Required property 'server_certificate_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def authorize_all_users_to_vpc_cidr(self) -> typing.Optional[builtins.bool]:
        '''Whether to authorize all users to the VPC CIDR.

        This automatically creates an authorization rule. Set this to ``false`` and
        use ``addAuthorizationRule()`` to create your own rules instead.

        :default: true
        '''
        result = self._values.get("authorize_all_users_to_vpc_cidr")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def client_certificate_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the client certificate for mutual authentication.

        The certificate must be signed by a certificate authority (CA) and it must
        be provisioned in AWS Certificate Manager (ACM).

        :default: - use user-based authentication
        '''
        result = self._values.get("client_certificate_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_connection_handler(
        self,
    ) -> typing.Optional["IClientVpnConnectionHandler"]:
        '''The AWS Lambda function used for connection authorization.

        The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix

        :default: - no connection handler
        '''
        result = self._values.get("client_connection_handler")
        return typing.cast(typing.Optional["IClientVpnConnectionHandler"], result)

    @builtins.property
    def client_login_banner(self) -> typing.Optional[builtins.str]:
        '''Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established.

        UTF-8 encoded characters only. Maximum of 1400 characters.

        :default: - no banner is presented to the client
        '''
        result = self._values.get("client_login_banner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the Client VPN endpoint.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dns_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Information about the DNS servers to be used for DNS resolution.

        A Client VPN endpoint can have up to two DNS servers.

        :default: - use the DNS address configured on the device
        '''
        result = self._values.get("dns_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def logging(self) -> typing.Optional[builtins.bool]:
        '''Whether to enable connections logging.

        :default: true
        '''
        result = self._values.get("logging")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def log_group(self) -> typing.Optional[_ILogGroup_3c4fa718]:
        '''A CloudWatch Logs log group for connection logging.

        :default: - a new group is created
        '''
        result = self._values.get("log_group")
        return typing.cast(typing.Optional[_ILogGroup_3c4fa718], result)

    @builtins.property
    def log_stream(self) -> typing.Optional[_ILogStream_dcfca8c2]:
        '''A CloudWatch Logs log stream for connection logging.

        :default: - a new stream is created
        '''
        result = self._values.get("log_stream")
        return typing.cast(typing.Optional[_ILogStream_dcfca8c2], result)

    @builtins.property
    def port(self) -> typing.Optional["VpnPort"]:
        '''The port number to assign to the Client VPN endpoint for TCP and UDP traffic.

        :default: VpnPort.HTTPS
        '''
        result = self._values.get("port")
        return typing.cast(typing.Optional["VpnPort"], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List["ISecurityGroup"]]:
        '''The security groups to apply to the target network.

        :default: - a new security group is created
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List["ISecurityGroup"]], result)

    @builtins.property
    def self_service_portal(self) -> typing.Optional[builtins.bool]:
        '''Specify whether to enable the self-service portal for the Client VPN endpoint.

        :default: true
        '''
        result = self._values.get("self_service_portal")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def session_timeout(self) -> typing.Optional["ClientVpnSessionTimeout"]:
        '''The maximum VPN session duration time.

        :default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        '''
        result = self._values.get("session_timeout")
        return typing.cast(typing.Optional["ClientVpnSessionTimeout"], result)

    @builtins.property
    def split_tunnel(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint.

        :default: false

        :see: https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html
        '''
        result = self._values.get("split_tunnel")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def transport_protocol(self) -> typing.Optional["TransportProtocol"]:
        '''The transport protocol to be used by the VPN session.

        :default: TransportProtocol.UDP
        '''
        result = self._values.get("transport_protocol")
        return typing.cast(typing.Optional["TransportProtocol"], result)

    @builtins.property
    def user_based_authentication(
        self,
    ) -> typing.Optional["ClientVpnUserBasedAuthentication"]:
        '''The type of user-based authentication to use.

        :default: - use mutual authentication

        :see: https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/client-authentication.html
        '''
        result = self._values.get("user_based_authentication")
        return typing.cast(typing.Optional["ClientVpnUserBasedAuthentication"], result)

    @builtins.property
    def vpc_subnets(self) -> typing.Optional["SubnetSelection"]:
        '''Subnets to associate to the client VPN endpoint.

        :default: - the VPC default strategy
        '''
        result = self._values.get("vpc_subnets")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnEndpointOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnEndpointProps",
    jsii_struct_bases=[ClientVpnEndpointOptions],
    name_mapping={
        "cidr": "cidr",
        "server_certificate_arn": "serverCertificateArn",
        "authorize_all_users_to_vpc_cidr": "authorizeAllUsersToVpcCidr",
        "client_certificate_arn": "clientCertificateArn",
        "client_connection_handler": "clientConnectionHandler",
        "client_login_banner": "clientLoginBanner",
        "description": "description",
        "dns_servers": "dnsServers",
        "logging": "logging",
        "log_group": "logGroup",
        "log_stream": "logStream",
        "port": "port",
        "security_groups": "securityGroups",
        "self_service_portal": "selfServicePortal",
        "session_timeout": "sessionTimeout",
        "split_tunnel": "splitTunnel",
        "transport_protocol": "transportProtocol",
        "user_based_authentication": "userBasedAuthentication",
        "vpc_subnets": "vpcSubnets",
        "vpc": "vpc",
    },
)
class ClientVpnEndpointProps(ClientVpnEndpointOptions):
    def __init__(
        self,
        *,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional["IClientVpnConnectionHandler"] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional["VpnPort"] = None,
        security_groups: typing.Optional[typing.Sequence["ISecurityGroup"]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional["ClientVpnSessionTimeout"] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional["TransportProtocol"] = None,
        user_based_authentication: typing.Optional["ClientVpnUserBasedAuthentication"] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
        vpc: "IVpc",
    ) -> None:
        '''Properties for a client VPN endpoint.

        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy
        :param vpc: The VPC to connect to.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_logs as logs
            
            # client_vpn_connection_handler: ec2.IClientVpnConnectionHandler
            # client_vpn_user_based_authentication: ec2.ClientVpnUserBasedAuthentication
            # log_group: logs.LogGroup
            # log_stream: logs.LogStream
            # security_group: ec2.SecurityGroup
            # subnet: ec2.Subnet
            # subnet_filter: ec2.SubnetFilter
            # vpc: ec2.Vpc
            
            client_vpn_endpoint_props = ec2.ClientVpnEndpointProps(
                cidr="cidr",
                server_certificate_arn="serverCertificateArn",
                vpc=vpc,
            
                # the properties below are optional
                authorize_all_users_to_vpc_cidr=False,
                client_certificate_arn="clientCertificateArn",
                client_connection_handler=client_vpn_connection_handler,
                client_login_banner="clientLoginBanner",
                description="description",
                dns_servers=["dnsServers"],
                logging=False,
                log_group=log_group,
                log_stream=log_stream,
                port=ec2.VpnPort.HTTPS,
                security_groups=[security_group],
                self_service_portal=False,
                session_timeout=ec2.ClientVpnSessionTimeout.EIGHT_HOURS,
                split_tunnel=False,
                transport_protocol=ec2.TransportProtocol.TCP,
                user_based_authentication=client_vpn_user_based_authentication,
                vpc_subnets=ec2.SubnetSelection(
                    availability_zones=["availabilityZones"],
                    one_per_az=False,
                    subnet_filters=[subnet_filter],
                    subnet_group_name="subnetGroupName",
                    subnets=[subnet],
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
                )
            )
        '''
        if isinstance(vpc_subnets, dict):
            vpc_subnets = SubnetSelection(**vpc_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8e89ba9082e1bc80500c526e8522c5a90e2a91bd17d985f5932611e0b60e10b3)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument server_certificate_arn", value=server_certificate_arn, expected_type=type_hints["server_certificate_arn"])
            check_type(argname="argument authorize_all_users_to_vpc_cidr", value=authorize_all_users_to_vpc_cidr, expected_type=type_hints["authorize_all_users_to_vpc_cidr"])
            check_type(argname="argument client_certificate_arn", value=client_certificate_arn, expected_type=type_hints["client_certificate_arn"])
            check_type(argname="argument client_connection_handler", value=client_connection_handler, expected_type=type_hints["client_connection_handler"])
            check_type(argname="argument client_login_banner", value=client_login_banner, expected_type=type_hints["client_login_banner"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument dns_servers", value=dns_servers, expected_type=type_hints["dns_servers"])
            check_type(argname="argument logging", value=logging, expected_type=type_hints["logging"])
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            check_type(argname="argument log_stream", value=log_stream, expected_type=type_hints["log_stream"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument self_service_portal", value=self_service_portal, expected_type=type_hints["self_service_portal"])
            check_type(argname="argument session_timeout", value=session_timeout, expected_type=type_hints["session_timeout"])
            check_type(argname="argument split_tunnel", value=split_tunnel, expected_type=type_hints["split_tunnel"])
            check_type(argname="argument transport_protocol", value=transport_protocol, expected_type=type_hints["transport_protocol"])
            check_type(argname="argument user_based_authentication", value=user_based_authentication, expected_type=type_hints["user_based_authentication"])
            check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "server_certificate_arn": server_certificate_arn,
            "vpc": vpc,
        }
        if authorize_all_users_to_vpc_cidr is not None:
            self._values["authorize_all_users_to_vpc_cidr"] = authorize_all_users_to_vpc_cidr
        if client_certificate_arn is not None:
            self._values["client_certificate_arn"] = client_certificate_arn
        if client_connection_handler is not None:
            self._values["client_connection_handler"] = client_connection_handler
        if client_login_banner is not None:
            self._values["client_login_banner"] = client_login_banner
        if description is not None:
            self._values["description"] = description
        if dns_servers is not None:
            self._values["dns_servers"] = dns_servers
        if logging is not None:
            self._values["logging"] = logging
        if log_group is not None:
            self._values["log_group"] = log_group
        if log_stream is not None:
            self._values["log_stream"] = log_stream
        if port is not None:
            self._values["port"] = port
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if self_service_portal is not None:
            self._values["self_service_portal"] = self_service_portal
        if session_timeout is not None:
            self._values["session_timeout"] = session_timeout
        if split_tunnel is not None:
            self._values["split_tunnel"] = split_tunnel
        if transport_protocol is not None:
            self._values["transport_protocol"] = transport_protocol
        if user_based_authentication is not None:
            self._values["user_based_authentication"] = user_based_authentication
        if vpc_subnets is not None:
            self._values["vpc_subnets"] = vpc_subnets

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, from which to assign client IP addresses.

        The address range cannot overlap with the local CIDR of the VPC
        in which the associated subnet is located, or the routes that you add manually.

        Changing the address range will replace the Client VPN endpoint.

        The CIDR block should be /22 or greater.
        '''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def server_certificate_arn(self) -> builtins.str:
        '''The ARN of the server certificate.'''
        result = self._values.get("server_certificate_arn")
        assert result is not None, "Required property 'server_certificate_arn' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def authorize_all_users_to_vpc_cidr(self) -> typing.Optional[builtins.bool]:
        '''Whether to authorize all users to the VPC CIDR.

        This automatically creates an authorization rule. Set this to ``false`` and
        use ``addAuthorizationRule()`` to create your own rules instead.

        :default: true
        '''
        result = self._values.get("authorize_all_users_to_vpc_cidr")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def client_certificate_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the client certificate for mutual authentication.

        The certificate must be signed by a certificate authority (CA) and it must
        be provisioned in AWS Certificate Manager (ACM).

        :default: - use user-based authentication
        '''
        result = self._values.get("client_certificate_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_connection_handler(
        self,
    ) -> typing.Optional["IClientVpnConnectionHandler"]:
        '''The AWS Lambda function used for connection authorization.

        The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix

        :default: - no connection handler
        '''
        result = self._values.get("client_connection_handler")
        return typing.cast(typing.Optional["IClientVpnConnectionHandler"], result)

    @builtins.property
    def client_login_banner(self) -> typing.Optional[builtins.str]:
        '''Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established.

        UTF-8 encoded characters only. Maximum of 1400 characters.

        :default: - no banner is presented to the client
        '''
        result = self._values.get("client_login_banner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the Client VPN endpoint.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def dns_servers(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Information about the DNS servers to be used for DNS resolution.

        A Client VPN endpoint can have up to two DNS servers.

        :default: - use the DNS address configured on the device
        '''
        result = self._values.get("dns_servers")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def logging(self) -> typing.Optional[builtins.bool]:
        '''Whether to enable connections logging.

        :default: true
        '''
        result = self._values.get("logging")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def log_group(self) -> typing.Optional[_ILogGroup_3c4fa718]:
        '''A CloudWatch Logs log group for connection logging.

        :default: - a new group is created
        '''
        result = self._values.get("log_group")
        return typing.cast(typing.Optional[_ILogGroup_3c4fa718], result)

    @builtins.property
    def log_stream(self) -> typing.Optional[_ILogStream_dcfca8c2]:
        '''A CloudWatch Logs log stream for connection logging.

        :default: - a new stream is created
        '''
        result = self._values.get("log_stream")
        return typing.cast(typing.Optional[_ILogStream_dcfca8c2], result)

    @builtins.property
    def port(self) -> typing.Optional["VpnPort"]:
        '''The port number to assign to the Client VPN endpoint for TCP and UDP traffic.

        :default: VpnPort.HTTPS
        '''
        result = self._values.get("port")
        return typing.cast(typing.Optional["VpnPort"], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List["ISecurityGroup"]]:
        '''The security groups to apply to the target network.

        :default: - a new security group is created
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List["ISecurityGroup"]], result)

    @builtins.property
    def self_service_portal(self) -> typing.Optional[builtins.bool]:
        '''Specify whether to enable the self-service portal for the Client VPN endpoint.

        :default: true
        '''
        result = self._values.get("self_service_portal")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def session_timeout(self) -> typing.Optional["ClientVpnSessionTimeout"]:
        '''The maximum VPN session duration time.

        :default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        '''
        result = self._values.get("session_timeout")
        return typing.cast(typing.Optional["ClientVpnSessionTimeout"], result)

    @builtins.property
    def split_tunnel(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint.

        :default: false

        :see: https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html
        '''
        result = self._values.get("split_tunnel")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def transport_protocol(self) -> typing.Optional["TransportProtocol"]:
        '''The transport protocol to be used by the VPN session.

        :default: TransportProtocol.UDP
        '''
        result = self._values.get("transport_protocol")
        return typing.cast(typing.Optional["TransportProtocol"], result)

    @builtins.property
    def user_based_authentication(
        self,
    ) -> typing.Optional["ClientVpnUserBasedAuthentication"]:
        '''The type of user-based authentication to use.

        :default: - use mutual authentication

        :see: https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/client-authentication.html
        '''
        result = self._values.get("user_based_authentication")
        return typing.cast(typing.Optional["ClientVpnUserBasedAuthentication"], result)

    @builtins.property
    def vpc_subnets(self) -> typing.Optional["SubnetSelection"]:
        '''Subnets to associate to the client VPN endpoint.

        :default: - the VPC default strategy
        '''
        result = self._values.get("vpc_subnets")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    @builtins.property
    def vpc(self) -> "IVpc":
        '''The VPC to connect to.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast("IVpc", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ClientVpnRoute(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnRoute",
):
    '''A client VPN route.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # client_vpn_endpoint: ec2.ClientVpnEndpoint
        # client_vpn_route_target: ec2.ClientVpnRouteTarget
        
        client_vpn_route = ec2.ClientVpnRoute(self, "MyClientVpnRoute",
            cidr="cidr",
            target=client_vpn_route_target,
        
            # the properties below are optional
            client_vpn_endpoint=client_vpn_endpoint,
            description="description"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        client_vpn_endpoint: typing.Optional["IClientVpnEndpoint"] = None,
        cidr: builtins.str,
        target: "ClientVpnRouteTarget",
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param client_vpn_endpoint: The client VPN endpoint to which to add the route. Default: clientVpnEndpoint is required
        :param cidr: The IPv4 address range, in CIDR notation, of the route destination. For example: - To add a route for Internet access, enter 0.0.0.0/0 - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target: The target for the route.
        :param description: A brief description of the authorization rule. Default: - no description
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c072da507844f8a068ea56fa36968badfeea4273e8fd69c18fe5d1d26ef9a8e5)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ClientVpnRouteProps(
            client_vpn_endpoint=client_vpn_endpoint,
            cidr=cidr,
            target=target,
            description=description,
        )

        jsii.create(self.__class__, self, [scope, id, props])


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnRouteOptions",
    jsii_struct_bases=[],
    name_mapping={"cidr": "cidr", "target": "target", "description": "description"},
)
class ClientVpnRouteOptions:
    def __init__(
        self,
        *,
        cidr: builtins.str,
        target: "ClientVpnRouteTarget",
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options for a ClientVpnRoute.

        :param cidr: The IPv4 address range, in CIDR notation, of the route destination. For example: - To add a route for Internet access, enter 0.0.0.0/0 - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target: The target for the route.
        :param description: A brief description of the authorization rule. Default: - no description

        :exampleMetadata: fixture=client-vpn infused

        Example::

            endpoint = vpc.add_client_vpn_endpoint("Endpoint",
                cidr="10.100.0.0/16",
                server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
                user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider)
            )
            
            # Client-to-client access
            endpoint.add_route("Route",
                cidr="10.100.0.0/16",
                target=ec2.ClientVpnRouteTarget.local()
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__02f852bc1d595c3b969e64ca7c8edc426c0f6957269d65c35c984f995497d8ae)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "target": target,
        }
        if description is not None:
            self._values["description"] = description

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the route destination.

        For example:

        - To add a route for Internet access, enter 0.0.0.0/0
        - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range
        - To add a route for an on-premises network, enter the AWS Site-to-Site VPN
          connection's IPv4 CIDR range
        - To add a route for the local network, enter the client CIDR range
        '''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def target(self) -> "ClientVpnRouteTarget":
        '''The target for the route.'''
        result = self._values.get("target")
        assert result is not None, "Required property 'target' is missing"
        return typing.cast("ClientVpnRouteTarget", result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnRouteOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnRouteProps",
    jsii_struct_bases=[ClientVpnRouteOptions],
    name_mapping={
        "cidr": "cidr",
        "target": "target",
        "description": "description",
        "client_vpn_endpoint": "clientVpnEndpoint",
    },
)
class ClientVpnRouteProps(ClientVpnRouteOptions):
    def __init__(
        self,
        *,
        cidr: builtins.str,
        target: "ClientVpnRouteTarget",
        description: typing.Optional[builtins.str] = None,
        client_vpn_endpoint: typing.Optional["IClientVpnEndpoint"] = None,
    ) -> None:
        '''Properties for a ClientVpnRoute.

        :param cidr: The IPv4 address range, in CIDR notation, of the route destination. For example: - To add a route for Internet access, enter 0.0.0.0/0 - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target: The target for the route.
        :param description: A brief description of the authorization rule. Default: - no description
        :param client_vpn_endpoint: The client VPN endpoint to which to add the route. Default: clientVpnEndpoint is required

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # client_vpn_endpoint: ec2.ClientVpnEndpoint
            # client_vpn_route_target: ec2.ClientVpnRouteTarget
            
            client_vpn_route_props = ec2.ClientVpnRouteProps(
                cidr="cidr",
                target=client_vpn_route_target,
            
                # the properties below are optional
                client_vpn_endpoint=client_vpn_endpoint,
                description="description"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9aebb8dc3b9f2f386d57a9b72a9af25ca254b4d99a708cb292f073f21129172a)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument client_vpn_endpoint", value=client_vpn_endpoint, expected_type=type_hints["client_vpn_endpoint"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "target": target,
        }
        if description is not None:
            self._values["description"] = description
        if client_vpn_endpoint is not None:
            self._values["client_vpn_endpoint"] = client_vpn_endpoint

    @builtins.property
    def cidr(self) -> builtins.str:
        '''The IPv4 address range, in CIDR notation, of the route destination.

        For example:

        - To add a route for Internet access, enter 0.0.0.0/0
        - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range
        - To add a route for an on-premises network, enter the AWS Site-to-Site VPN
          connection's IPv4 CIDR range
        - To add a route for the local network, enter the client CIDR range
        '''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def target(self) -> "ClientVpnRouteTarget":
        '''The target for the route.'''
        result = self._values.get("target")
        assert result is not None, "Required property 'target' is missing"
        return typing.cast("ClientVpnRouteTarget", result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A brief description of the authorization rule.

        :default: - no description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def client_vpn_endpoint(self) -> typing.Optional["IClientVpnEndpoint"]:
        '''The client VPN endpoint to which to add the route.

        :default: clientVpnEndpoint is required
        '''
        result = self._values.get("client_vpn_endpoint")
        return typing.cast(typing.Optional["IClientVpnEndpoint"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ClientVpnRouteProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class ClientVpnRouteTarget(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnRouteTarget",
):
    '''Target for a client VPN route.

    :exampleMetadata: fixture=client-vpn infused

    Example::

        endpoint = vpc.add_client_vpn_endpoint("Endpoint",
            cidr="10.100.0.0/16",
            server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
            user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider)
        )
        
        # Client-to-client access
        endpoint.add_route("Route",
            cidr="10.100.0.0/16",
            target=ec2.ClientVpnRouteTarget.local()
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="local")
    @builtins.classmethod
    def local(cls) -> "ClientVpnRouteTarget":
        '''Local network.'''
        return typing.cast("ClientVpnRouteTarget", jsii.sinvoke(cls, "local", []))

    @jsii.member(jsii_name="subnet")
    @builtins.classmethod
    def subnet(cls, subnet: "ISubnet") -> "ClientVpnRouteTarget":
        '''Subnet.

        The specified subnet must be an existing target network of the client VPN
        endpoint.

        :param subnet: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb562b03168df2ba61364ce7a57936d64dc7317de907fc9d7fb2c5843aac598c)
            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
        return typing.cast("ClientVpnRouteTarget", jsii.sinvoke(cls, "subnet", [subnet]))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    @abc.abstractmethod
    def subnet_id(self) -> builtins.str:
        '''The subnet ID.'''
        ...


class _ClientVpnRouteTargetProxy(ClientVpnRouteTarget):
    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The subnet ID.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, ClientVpnRouteTarget).__jsii_proxy_class__ = lambda : _ClientVpnRouteTargetProxy


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.ClientVpnSessionTimeout")
class ClientVpnSessionTimeout(enum.Enum):
    '''Maximum VPN session duration time.'''

    EIGHT_HOURS = "EIGHT_HOURS"
    '''8 hours.'''
    TEN_HOURS = "TEN_HOURS"
    '''10 hours.'''
    TWELVE_HOURS = "TWELVE_HOURS"
    '''12 hours.'''
    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS"
    '''24 hours.'''


class ClientVpnUserBasedAuthentication(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnUserBasedAuthentication",
):
    '''User-based authentication for a client VPN endpoint.

    :exampleMetadata: fixture=client-vpn infused

    Example::

        endpoint = vpc.add_client_vpn_endpoint("Endpoint",
            cidr="10.100.0.0/16",
            server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
            user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider),
            authorize_all_users_to_vpc_cidr=False
        )
        
        endpoint.add_authorization_rule("Rule",
            cidr="10.0.10.0/32",
            group_id="group-id"
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="activeDirectory")
    @builtins.classmethod
    def active_directory(
        cls,
        directory_id: builtins.str,
    ) -> "ClientVpnUserBasedAuthentication":
        '''Active Directory authentication.

        :param directory_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae62dcea9e6df35a85e3499917627b34f95268abe3a5a1afdbf25a382be28238)
            check_type(argname="argument directory_id", value=directory_id, expected_type=type_hints["directory_id"])
        return typing.cast("ClientVpnUserBasedAuthentication", jsii.sinvoke(cls, "activeDirectory", [directory_id]))

    @jsii.member(jsii_name="federated")
    @builtins.classmethod
    def federated(
        cls,
        saml_provider: _ISamlProvider_63f03582,
        self_service_saml_provider: typing.Optional[_ISamlProvider_63f03582] = None,
    ) -> "ClientVpnUserBasedAuthentication":
        '''Federated authentication.

        :param saml_provider: -
        :param self_service_saml_provider: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6bcf03d221545d954a7409f612a38519f9e0fdf2566a3537ed47f8df0d1a642c)
            check_type(argname="argument saml_provider", value=saml_provider, expected_type=type_hints["saml_provider"])
            check_type(argname="argument self_service_saml_provider", value=self_service_saml_provider, expected_type=type_hints["self_service_saml_provider"])
        return typing.cast("ClientVpnUserBasedAuthentication", jsii.sinvoke(cls, "federated", [saml_provider, self_service_saml_provider]))

    @jsii.member(jsii_name="render")
    @abc.abstractmethod
    def render(self) -> typing.Any:
        '''Renders the user based authentication.'''
        ...


class _ClientVpnUserBasedAuthenticationProxy(ClientVpnUserBasedAuthentication):
    @jsii.member(jsii_name="render")
    def render(self) -> typing.Any:
        '''Renders the user based authentication.'''
        return typing.cast(typing.Any, jsii.invoke(self, "render", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, ClientVpnUserBasedAuthentication).__jsii_proxy_class__ = lambda : _ClientVpnUserBasedAuthenticationProxy


class CloudFormationInit(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.CloudFormationInit",
):
    '''A CloudFormation-init configuration.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
        
            init=ec2.CloudFormationInit.from_elements(
                # Create a simple config file that runs a Python web server
                ec2.InitService.systemd_config_file("simpleserver",
                    command="/usr/bin/python3 -m http.server 8080",
                    cwd="/var/www/html"
                ),
                # Start the server using SystemD
                ec2.InitService.enable("simpleserver",
                    service_manager=ec2.ServiceManager.SYSTEMD
                ),
                # Drop an example file to show the web server working
                ec2.InitFile.from_string("/var/www/html/index.html", "Hello! It's working!"))
        )
    '''

    @jsii.member(jsii_name="fromConfig")
    @builtins.classmethod
    def from_config(cls, config: "InitConfig") -> "CloudFormationInit":
        '''Use an existing InitConfig object as the default and only config.

        :param config: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e7eb6c53f66a5111d286ac86bf0932ad0ec7c97e10450d8210c36b0b50e38754)
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
        return typing.cast("CloudFormationInit", jsii.sinvoke(cls, "fromConfig", [config]))

    @jsii.member(jsii_name="fromConfigSets")
    @builtins.classmethod
    def from_config_sets(
        cls,
        *,
        configs: typing.Mapping[builtins.str, "InitConfig"],
        config_sets: typing.Mapping[builtins.str, typing.Sequence[builtins.str]],
    ) -> "CloudFormationInit":
        '''Build a CloudFormationInit from config sets.

        :param configs: The sets of configs to pick from.
        :param config_sets: The definitions of each config set.
        '''
        props = ConfigSetProps(configs=configs, config_sets=config_sets)

        return typing.cast("CloudFormationInit", jsii.sinvoke(cls, "fromConfigSets", [props]))

    @jsii.member(jsii_name="fromElements")
    @builtins.classmethod
    def from_elements(cls, *elements: "InitElement") -> "CloudFormationInit":
        '''Build a new config from a set of Init Elements.

        :param elements: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6eafe1378ef68d49892c98ec2694c74a60615aea346240fcfa0fa07b14e6c879)
            check_type(argname="argument elements", value=elements, expected_type=typing.Tuple[type_hints["elements"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast("CloudFormationInit", jsii.sinvoke(cls, "fromElements", [*elements]))

    @jsii.member(jsii_name="addConfig")
    def add_config(self, config_name: builtins.str, config: "InitConfig") -> None:
        '''Add a config with the given name to this CloudFormationInit object.

        :param config_name: -
        :param config: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bf8dcab27683c66ad2d91b1b6b94993856dc6d5b8727f690e4b99208c986bcfe)
            check_type(argname="argument config_name", value=config_name, expected_type=type_hints["config_name"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
        return typing.cast(None, jsii.invoke(self, "addConfig", [config_name, config]))

    @jsii.member(jsii_name="addConfigSet")
    def add_config_set(
        self,
        config_set_name: builtins.str,
        config_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''Add a config set with the given name to this CloudFormationInit object.

        The new configset will reference the given configs in the given order.

        :param config_set_name: -
        :param config_names: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f4517553431ffde7bf841015c186e708b91a97e3de37c86084362663f9c60296)
            check_type(argname="argument config_set_name", value=config_set_name, expected_type=type_hints["config_set_name"])
            check_type(argname="argument config_names", value=config_names, expected_type=type_hints["config_names"])
        return typing.cast(None, jsii.invoke(self, "addConfigSet", [config_set_name, config_names]))

    @jsii.member(jsii_name="attach")
    def attach(
        self,
        attached_resource: _CfnResource_9df397a6,
        *,
        instance_role: _IRole_235f5d8e,
        platform: "OperatingSystemType",
        user_data: "UserData",
        config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
        embed_fingerprint: typing.Optional[builtins.bool] = None,
        ignore_failures: typing.Optional[builtins.bool] = None,
        include_role: typing.Optional[builtins.bool] = None,
        include_url: typing.Optional[builtins.bool] = None,
        print_log: typing.Optional[builtins.bool] = None,
        signal_resource: typing.Optional[_CfnResource_9df397a6] = None,
    ) -> None:
        '''Attach the CloudFormation Init config to the given resource.

        As an app builder, use ``instance.applyCloudFormationInit()`` or
        ``autoScalingGroup.applyCloudFormationInit()`` to trigger this method.

        This method does the following:

        - Renders the ``AWS::CloudFormation::Init`` object to the given resource's
          metadata, potentially adding a ``AWS::CloudFormation::Authentication`` object
          next to it if required.
        - Updates the instance role policy to be able to call the APIs required for
          ``cfn-init`` and ``cfn-signal`` to work, and potentially add permissions to download
          referenced asset and bucket resources.
        - Updates the given UserData with commands to execute the ``cfn-init`` script.

        :param attached_resource: -
        :param instance_role: Instance role of the consuming instance or fleet.
        :param platform: OS Platform the init config will be used for.
        :param user_data: UserData to add commands to.
        :param config_sets: ConfigSet to activate. Default: ['default']
        :param embed_fingerprint: Whether to embed a hash into the userData. If ``true`` (the default), a hash of the config will be embedded into the UserData, so that if the config changes, the UserData changes and the instance will be replaced. If ``false``, no such hash will be embedded, and if the CloudFormation Init config changes nothing will happen to the running instance. Default: true
        :param ignore_failures: Don't fail the instance creation when cfn-init fails. You can use this to prevent CloudFormation from rolling back when instances fail to start up, to help in debugging. Default: false
        :param include_role: Include --role argument when running cfn-init and cfn-signal commands. This will be the IAM instance profile attached to the EC2 instance Default: false
        :param include_url: Include --url argument when running cfn-init and cfn-signal commands. This will be the cloudformation endpoint in the deployed region e.g. https://cloudformation.us-east-1.amazonaws.com Default: false
        :param print_log: Print the results of running cfn-init to the Instance System Log. By default, the output of running cfn-init is written to a log file on the instance. Set this to ``true`` to print it to the System Log (visible from the EC2 Console), ``false`` to not print it. (Be aware that the system log is refreshed at certain points in time of the instance life cycle, and successful execution may not always show up). Default: true
        :param signal_resource: When provided, signals this resource instead of the attached resource. You can use this to support signaling LaunchTemplate while attaching AutoScalingGroup Default: - if this property is undefined cfn-signal signals the attached resource
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b4d3aa9f259ce8b05d6823c86e00c437a78f66039a8695636937742528967fdf)
            check_type(argname="argument attached_resource", value=attached_resource, expected_type=type_hints["attached_resource"])
        attach_options = AttachInitOptions(
            instance_role=instance_role,
            platform=platform,
            user_data=user_data,
            config_sets=config_sets,
            embed_fingerprint=embed_fingerprint,
            ignore_failures=ignore_failures,
            include_role=include_role,
            include_url=include_url,
            print_log=print_log,
            signal_resource=signal_resource,
        )

        return typing.cast(None, jsii.invoke(self, "attach", [attached_resource, attach_options]))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CommonNetworkAclEntryOptions",
    jsii_struct_bases=[],
    name_mapping={
        "cidr": "cidr",
        "rule_number": "ruleNumber",
        "traffic": "traffic",
        "direction": "direction",
        "network_acl_entry_name": "networkAclEntryName",
        "rule_action": "ruleAction",
    },
)
class CommonNetworkAclEntryOptions:
    def __init__(
        self,
        *,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
    ) -> None:
        '''Basic NetworkACL entry props.

        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # acl_cidr: ec2.AclCidr
            # acl_traffic: ec2.AclTraffic
            
            common_network_acl_entry_options = ec2.CommonNetworkAclEntryOptions(
                cidr=acl_cidr,
                rule_number=123,
                traffic=acl_traffic,
            
                # the properties below are optional
                direction=ec2.TrafficDirection.EGRESS,
                network_acl_entry_name="networkAclEntryName",
                rule_action=ec2.Action.ALLOW
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__851215aa7244914b1f8c755008192b40abf6bc0a46f4a061a8349af6c03f1177)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument rule_number", value=rule_number, expected_type=type_hints["rule_number"])
            check_type(argname="argument traffic", value=traffic, expected_type=type_hints["traffic"])
            check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
            check_type(argname="argument network_acl_entry_name", value=network_acl_entry_name, expected_type=type_hints["network_acl_entry_name"])
            check_type(argname="argument rule_action", value=rule_action, expected_type=type_hints["rule_action"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "rule_number": rule_number,
            "traffic": traffic,
        }
        if direction is not None:
            self._values["direction"] = direction
        if network_acl_entry_name is not None:
            self._values["network_acl_entry_name"] = network_acl_entry_name
        if rule_action is not None:
            self._values["rule_action"] = rule_action

    @builtins.property
    def cidr(self) -> AclCidr:
        '''The CIDR range to allow or deny.'''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(AclCidr, result)

    @builtins.property
    def rule_number(self) -> jsii.Number:
        '''Rule number to assign to the entry, such as 100.

        ACL entries are processed in ascending order by rule number.
        Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        '''
        result = self._values.get("rule_number")
        assert result is not None, "Required property 'rule_number' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def traffic(self) -> AclTraffic:
        '''What kind of traffic this ACL rule applies to.'''
        result = self._values.get("traffic")
        assert result is not None, "Required property 'traffic' is missing"
        return typing.cast(AclTraffic, result)

    @builtins.property
    def direction(self) -> typing.Optional["TrafficDirection"]:
        '''Traffic direction, with respect to the subnet, this rule applies to.

        :default: TrafficDirection.INGRESS
        '''
        result = self._values.get("direction")
        return typing.cast(typing.Optional["TrafficDirection"], result)

    @builtins.property
    def network_acl_entry_name(self) -> typing.Optional[builtins.str]:
        '''The name of the NetworkAclEntry.

        It is not recommended to use an explicit group name.

        :default:

        If you don't specify a NetworkAclName, AWS CloudFormation generates a
        unique physical ID and uses that ID for the group name.
        '''
        result = self._values.get("network_acl_entry_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def rule_action(self) -> typing.Optional[Action]:
        '''Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny".

        Any traffic that is not explicitly allowed is automatically denied in a custom
        ACL, all traffic is automatically allowed in a default ACL.

        :default: ALLOW
        '''
        result = self._values.get("rule_action")
        return typing.cast(typing.Optional[Action], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CommonNetworkAclEntryOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ConfigSetProps",
    jsii_struct_bases=[],
    name_mapping={"configs": "configs", "config_sets": "configSets"},
)
class ConfigSetProps:
    def __init__(
        self,
        *,
        configs: typing.Mapping[builtins.str, "InitConfig"],
        config_sets: typing.Mapping[builtins.str, typing.Sequence[builtins.str]],
    ) -> None:
        '''Options for CloudFormationInit.withConfigSets.

        :param configs: The sets of configs to pick from.
        :param config_sets: The definitions of each config set.

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            # instance_type: ec2.InstanceType
            # machine_image: ec2.IMachineImage
            
            
            ec2.Instance(self, "Instance",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=machine_image,
            
                # Showing the most complex setup, if you have simpler requirements
                # you can use `CloudFormationInit.fromElements()`.
                init=ec2.CloudFormationInit.from_config_sets(
                    config_sets={
                        # Applies the configs below in this order
                        "default": ["yumPreinstall", "config"]
                    },
                    configs={
                        "yum_preinstall": ec2.InitConfig([
                            # Install an Amazon Linux package using yum
                            ec2.InitPackage.yum("git")
                        ]),
                        "config": ec2.InitConfig([
                            # Create a JSON file from tokens (can also create other files)
                            ec2.InitFile.from_object("/etc/stack.json", {
                                "stack_id": Stack.of(self).stack_id,
                                "stack_name": Stack.of(self).stack_name,
                                "region": Stack.of(self).region
                            }),
            
                            # Create a group and user
                            ec2.InitGroup.from_name("my-group"),
                            ec2.InitUser.from_name("my-user"),
            
                            # Install an RPM from the internet
                            ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                        ])
                    }
                ),
                init_options=ec2.ApplyCloudFormationInitOptions(
                    # Optional, which configsets to activate (['default'] by default)
                    config_sets=["default"],
            
                    # Optional, how long the installation is expected to take (5 minutes by default)
                    timeout=Duration.minutes(30),
            
                    # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                    include_url=True,
            
                    # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                    include_role=True
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a665123442e326bdbe182187f593792660e9abb39a89874372fb5e4111d663dc)
            check_type(argname="argument configs", value=configs, expected_type=type_hints["configs"])
            check_type(argname="argument config_sets", value=config_sets, expected_type=type_hints["config_sets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "configs": configs,
            "config_sets": config_sets,
        }

    @builtins.property
    def configs(self) -> typing.Mapping[builtins.str, "InitConfig"]:
        '''The sets of configs to pick from.'''
        result = self._values.get("configs")
        assert result is not None, "Required property 'configs' is missing"
        return typing.cast(typing.Mapping[builtins.str, "InitConfig"], result)

    @builtins.property
    def config_sets(self) -> typing.Mapping[builtins.str, typing.List[builtins.str]]:
        '''The definitions of each config set.'''
        result = self._values.get("config_sets")
        assert result is not None, "Required property 'config_sets' is missing"
        return typing.cast(typing.Mapping[builtins.str, typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ConfigSetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ConfigureNatOptions",
    jsii_struct_bases=[],
    name_mapping={
        "nat_subnets": "natSubnets",
        "private_subnets": "privateSubnets",
        "vpc": "vpc",
    },
)
class ConfigureNatOptions:
    def __init__(
        self,
        *,
        nat_subnets: typing.Sequence["PublicSubnet"],
        private_subnets: typing.Sequence["PrivateSubnet"],
        vpc: "Vpc",
    ) -> None:
        '''Options passed by the VPC when NAT needs to be configured.

        :param nat_subnets: The public subnets where the NAT providers need to be placed.
        :param private_subnets: The private subnets that need to route through the NAT providers. There may be more private subnets than public subnets with NAT providers.
        :param vpc: The VPC we're configuring NAT for.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # private_subnet: ec2.PrivateSubnet
            # public_subnet: ec2.PublicSubnet
            # vpc: ec2.Vpc
            
            configure_nat_options = ec2.ConfigureNatOptions(
                nat_subnets=[public_subnet],
                private_subnets=[private_subnet],
                vpc=vpc
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30190f3dbbe85d18aad8aa25317ab070d8cbb51a15a9e6f0388b0df3a464ad41)
            check_type(argname="argument nat_subnets", value=nat_subnets, expected_type=type_hints["nat_subnets"])
            check_type(argname="argument private_subnets", value=private_subnets, expected_type=type_hints["private_subnets"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "nat_subnets": nat_subnets,
            "private_subnets": private_subnets,
            "vpc": vpc,
        }

    @builtins.property
    def nat_subnets(self) -> typing.List["PublicSubnet"]:
        '''The public subnets where the NAT providers need to be placed.'''
        result = self._values.get("nat_subnets")
        assert result is not None, "Required property 'nat_subnets' is missing"
        return typing.cast(typing.List["PublicSubnet"], result)

    @builtins.property
    def private_subnets(self) -> typing.List["PrivateSubnet"]:
        '''The private subnets that need to route through the NAT providers.

        There may be more private subnets than public subnets with NAT providers.
        '''
        result = self._values.get("private_subnets")
        assert result is not None, "Required property 'private_subnets' is missing"
        return typing.cast(typing.List["PrivateSubnet"], result)

    @builtins.property
    def vpc(self) -> "Vpc":
        '''The VPC we're configuring NAT for.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast("Vpc", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ConfigureNatOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ConnectionRule",
    jsii_struct_bases=[],
    name_mapping={
        "from_port": "fromPort",
        "description": "description",
        "protocol": "protocol",
        "to_port": "toPort",
    },
)
class ConnectionRule:
    def __init__(
        self,
        *,
        from_port: jsii.Number,
        description: typing.Optional[builtins.str] = None,
        protocol: typing.Optional[builtins.str] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param from_port: Start of port range for the TCP and UDP protocols, or an ICMP type number. If you specify icmp for the IpProtocol property, you can specify -1 as a wildcard (i.e., any ICMP type number).
        :param description: Description of this connection. It is applied to both the ingress rule and the egress rule. Default: No description
        :param protocol: The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers). Use -1 to specify all protocols. If you specify -1, or a protocol number other than tcp, udp, icmp, or 58 (ICMPv6), traffic on all ports is allowed, regardless of any ports you specify. For tcp, udp, and icmp, you must specify a port range. For protocol 58 (ICMPv6), you can optionally specify a port range; if you don't, traffic for all types and codes is allowed. Default: tcp
        :param to_port: End of port range for the TCP and UDP protocols, or an ICMP code. If you specify icmp for the IpProtocol property, you can specify -1 as a wildcard (i.e., any ICMP code). Default: If toPort is not specified, it will be the same as fromPort.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            connection_rule = ec2.ConnectionRule(
                from_port=123,
            
                # the properties below are optional
                description="description",
                protocol="protocol",
                to_port=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c3c97bf6fec5afd257e2e9b500690dc886a5091de9e05e08b9b9e1f9c625bf0a)
            check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "from_port": from_port,
        }
        if description is not None:
            self._values["description"] = description
        if protocol is not None:
            self._values["protocol"] = protocol
        if to_port is not None:
            self._values["to_port"] = to_port

    @builtins.property
    def from_port(self) -> jsii.Number:
        '''Start of port range for the TCP and UDP protocols, or an ICMP type number.

        If you specify icmp for the IpProtocol property, you can specify
        -1 as a wildcard (i.e., any ICMP type number).
        '''
        result = self._values.get("from_port")
        assert result is not None, "Required property 'from_port' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''Description of this connection.

        It is applied to both the ingress rule
        and the egress rule.

        :default: No description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def protocol(self) -> typing.Optional[builtins.str]:
        '''The IP protocol name (tcp, udp, icmp) or number (see Protocol Numbers).

        Use -1 to specify all protocols. If you specify -1, or a protocol number
        other than tcp, udp, icmp, or 58 (ICMPv6), traffic on all ports is
        allowed, regardless of any ports you specify. For tcp, udp, and icmp, you
        must specify a port range. For protocol 58 (ICMPv6), you can optionally
        specify a port range; if you don't, traffic for all types and codes is
        allowed.

        :default: tcp
        '''
        result = self._values.get("protocol")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''End of port range for the TCP and UDP protocols, or an ICMP code.

        If you specify icmp for the IpProtocol property, you can specify -1 as a
        wildcard (i.e., any ICMP code).

        :default: If toPort is not specified, it will be the same as fromPort.
        '''
        result = self._values.get("to_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ConnectionRule(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ConnectionsProps",
    jsii_struct_bases=[],
    name_mapping={
        "default_port": "defaultPort",
        "peer": "peer",
        "security_groups": "securityGroups",
    },
)
class ConnectionsProps:
    def __init__(
        self,
        *,
        default_port: typing.Optional["Port"] = None,
        peer: typing.Optional["IPeer"] = None,
        security_groups: typing.Optional[typing.Sequence["ISecurityGroup"]] = None,
    ) -> None:
        '''Properties to intialize a new Connections object.

        :param default_port: Default port range for initiating connections to and from this object. Default: - No default port
        :param peer: Class that represents the rule by which others can connect to this connectable. This object is required, but will be derived from securityGroup if that is passed. Default: Derived from securityGroup if set.
        :param security_groups: What securityGroup(s) this object is managing connections for. Default: No security groups

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # peer: ec2.IPeer
            # port: ec2.Port
            # security_group: ec2.SecurityGroup
            
            connections_props = ec2.ConnectionsProps(
                default_port=port,
                peer=peer,
                security_groups=[security_group]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9cb7eea3f313a061551c330a7ea339f496e026dbdc6a0984224bd0810bf1ebe)
            check_type(argname="argument default_port", value=default_port, expected_type=type_hints["default_port"])
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if default_port is not None:
            self._values["default_port"] = default_port
        if peer is not None:
            self._values["peer"] = peer
        if security_groups is not None:
            self._values["security_groups"] = security_groups

    @builtins.property
    def default_port(self) -> typing.Optional["Port"]:
        '''Default port range for initiating connections to and from this object.

        :default: - No default port
        '''
        result = self._values.get("default_port")
        return typing.cast(typing.Optional["Port"], result)

    @builtins.property
    def peer(self) -> typing.Optional["IPeer"]:
        '''Class that represents the rule by which others can connect to this connectable.

        This object is required, but will be derived from securityGroup if that is passed.

        :default: Derived from securityGroup if set.
        '''
        result = self._values.get("peer")
        return typing.cast(typing.Optional["IPeer"], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List["ISecurityGroup"]]:
        '''What securityGroup(s) this object is managing connections for.

        :default: No security groups
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List["ISecurityGroup"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ConnectionsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.CpuCredits")
class CpuCredits(enum.Enum):
    '''Provides the options for specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-how-to.html
    '''

    STANDARD = "STANDARD"
    '''Standard bursting mode.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-standard-mode.html
    '''
    UNLIMITED = "UNLIMITED"
    '''Unlimited bursting mode.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode.html
    '''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.CreateIpv6CidrBlocksRequest",
    jsii_struct_bases=[],
    name_mapping={
        "ipv6_selected_cidr": "ipv6SelectedCidr",
        "subnet_count": "subnetCount",
        "size_mask": "sizeMask",
    },
)
class CreateIpv6CidrBlocksRequest:
    def __init__(
        self,
        *,
        ipv6_selected_cidr: builtins.str,
        subnet_count: jsii.Number,
        size_mask: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Request for IPv6 CIDR block to be split up.

        :param ipv6_selected_cidr: The IPv6 CIDR block string representation.
        :param subnet_count: The number of subnets to assign CIDRs to.
        :param size_mask: Size of the covered bits in the CIDR. Default: - 128 - 64 = /64 CIDR.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            create_ipv6_cidr_blocks_request = ec2.CreateIpv6CidrBlocksRequest(
                ipv6_selected_cidr="ipv6SelectedCidr",
                subnet_count=123,
            
                # the properties below are optional
                size_mask="sizeMask"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d96a376ced2a799b1796cc6301f10d9c2070dbee68e3ab38d7bf98a6816d203a)
            check_type(argname="argument ipv6_selected_cidr", value=ipv6_selected_cidr, expected_type=type_hints["ipv6_selected_cidr"])
            check_type(argname="argument subnet_count", value=subnet_count, expected_type=type_hints["subnet_count"])
            check_type(argname="argument size_mask", value=size_mask, expected_type=type_hints["size_mask"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ipv6_selected_cidr": ipv6_selected_cidr,
            "subnet_count": subnet_count,
        }
        if size_mask is not None:
            self._values["size_mask"] = size_mask

    @builtins.property
    def ipv6_selected_cidr(self) -> builtins.str:
        '''The IPv6 CIDR block string representation.'''
        result = self._values.get("ipv6_selected_cidr")
        assert result is not None, "Required property 'ipv6_selected_cidr' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def subnet_count(self) -> jsii.Number:
        '''The number of subnets to assign CIDRs to.'''
        result = self._values.get("subnet_count")
        assert result is not None, "Required property 'subnet_count' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def size_mask(self) -> typing.Optional[builtins.str]:
        '''Size of the covered bits in the CIDR.

        :default: - 128 - 64 = /64 CIDR.
        '''
        result = self._values.get("size_mask")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CreateIpv6CidrBlocksRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.DefaultInstanceTenancy")
class DefaultInstanceTenancy(enum.Enum):
    '''The default tenancy of instances launched into the VPC.'''

    DEFAULT = "DEFAULT"
    '''Instances can be launched with any tenancy.'''
    DEDICATED = "DEDICATED"
    '''Any instance launched into the VPC automatically has dedicated tenancy, unless you launch it with the default tenancy.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.EbsDeviceOptionsBase",
    jsii_struct_bases=[],
    name_mapping={
        "delete_on_termination": "deleteOnTermination",
        "iops": "iops",
        "volume_type": "volumeType",
    },
)
class EbsDeviceOptionsBase:
    def __init__(
        self,
        *,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional["EbsDeviceVolumeType"] = None,
    ) -> None:
        '''Base block device options for an EBS volume.

        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            ebs_device_options_base = ec2.EbsDeviceOptionsBase(
                delete_on_termination=False,
                iops=123,
                volume_type=ec2.EbsDeviceVolumeType.STANDARD
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d06a3c480f0a868f3c69b22935c359322b1d9337591dc27bb141d518434f062)
            check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if delete_on_termination is not None:
            self._values["delete_on_termination"] = delete_on_termination
        if iops is not None:
            self._values["iops"] = iops
        if volume_type is not None:
            self._values["volume_type"] = volume_type

    @builtins.property
    def delete_on_termination(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether to delete the volume when the instance is terminated.

        :default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        '''
        result = self._values.get("delete_on_termination")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS) to provision for the volume.

        Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1``

        The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS,
        you need at least 100 GiB storage on the volume.

        :default: - none, required for ``EbsDeviceVolumeType.IO1``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_type(self) -> typing.Optional["EbsDeviceVolumeType"]:
        '''The EBS volume type.

        :default: ``EbsDeviceVolumeType.GP2``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional["EbsDeviceVolumeType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EbsDeviceOptionsBase(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.EbsDeviceSnapshotOptions",
    jsii_struct_bases=[EbsDeviceOptionsBase],
    name_mapping={
        "delete_on_termination": "deleteOnTermination",
        "iops": "iops",
        "volume_type": "volumeType",
        "volume_size": "volumeSize",
    },
)
class EbsDeviceSnapshotOptions(EbsDeviceOptionsBase):
    def __init__(
        self,
        *,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional["EbsDeviceVolumeType"] = None,
        volume_size: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Block device options for an EBS volume created from a snapshot.

        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``
        :param volume_size: The volume size, in Gibibytes (GiB). If you specify volumeSize, it must be equal or greater than the size of the snapshot. Default: - The snapshot size

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            ebs_device_snapshot_options = ec2.EbsDeviceSnapshotOptions(
                delete_on_termination=False,
                iops=123,
                volume_size=123,
                volume_type=ec2.EbsDeviceVolumeType.STANDARD
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4602c5be3c93ca5d255adf8aa3a652b8c7898310f96514ecd6fc09f7d5935370)
            check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if delete_on_termination is not None:
            self._values["delete_on_termination"] = delete_on_termination
        if iops is not None:
            self._values["iops"] = iops
        if volume_type is not None:
            self._values["volume_type"] = volume_type
        if volume_size is not None:
            self._values["volume_size"] = volume_size

    @builtins.property
    def delete_on_termination(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether to delete the volume when the instance is terminated.

        :default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        '''
        result = self._values.get("delete_on_termination")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS) to provision for the volume.

        Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1``

        The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS,
        you need at least 100 GiB storage on the volume.

        :default: - none, required for ``EbsDeviceVolumeType.IO1``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_type(self) -> typing.Optional["EbsDeviceVolumeType"]:
        '''The EBS volume type.

        :default: ``EbsDeviceVolumeType.GP2``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional["EbsDeviceVolumeType"], result)

    @builtins.property
    def volume_size(self) -> typing.Optional[jsii.Number]:
        '''The volume size, in Gibibytes (GiB).

        If you specify volumeSize, it must be equal or greater than the size of the snapshot.

        :default: - The snapshot size
        '''
        result = self._values.get("volume_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EbsDeviceSnapshotOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.EbsDeviceVolumeType")
class EbsDeviceVolumeType(enum.Enum):
    '''Supported EBS volume types for blockDevices.

    :exampleMetadata: infused

    Example::

        domain = es.Domain(self, "Domain",
            version=es.ElasticsearchVersion.V7_4,
            ebs=es.EbsOptions(
                volume_size=100,
                volume_type=ec2.EbsDeviceVolumeType.GENERAL_PURPOSE_SSD
            ),
            node_to_node_encryption=True,
            encryption_at_rest=es.EncryptionAtRestOptions(
                enabled=True
            )
        )
    '''

    STANDARD = "STANDARD"
    '''Magnetic.'''
    IO1 = "IO1"
    '''Provisioned IOPS SSD - IO1.'''
    IO2 = "IO2"
    '''Provisioned IOPS SSD - IO2.'''
    GP2 = "GP2"
    '''General Purpose SSD - GP2.'''
    GP3 = "GP3"
    '''General Purpose SSD - GP3.'''
    ST1 = "ST1"
    '''Throughput Optimized HDD.'''
    SC1 = "SC1"
    '''Cold HDD.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.ExecuteFileOptions",
    jsii_struct_bases=[],
    name_mapping={"file_path": "filePath", "arguments": "arguments"},
)
class ExecuteFileOptions:
    def __init__(
        self,
        *,
        file_path: builtins.str,
        arguments: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options when executing a file.

        :param file_path: The path to the file.
        :param arguments: The arguments to be passed to the file. Default: No arguments are passed to the file.

        :exampleMetadata: infused

        Example::

            from aws_cdk.aws_s3_assets import Asset
            
            # instance: ec2.Instance
            
            
            asset = Asset(self, "Asset",
                path="./configure.sh"
            )
            
            local_path = instance.user_data.add_s3_download_command(
                bucket=asset.bucket,
                bucket_key=asset.s3_object_key,
                region="us-east-1"
            )
            instance.user_data.add_execute_file_command(
                file_path=local_path,
                arguments="--verbose -y"
            )
            asset.grant_read(instance.role)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60130c664cd59ecac73373233b0978858b0e5c36c866ccdecbde22bbd7b8ef52)
            check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
            check_type(argname="argument arguments", value=arguments, expected_type=type_hints["arguments"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "file_path": file_path,
        }
        if arguments is not None:
            self._values["arguments"] = arguments

    @builtins.property
    def file_path(self) -> builtins.str:
        '''The path to the file.'''
        result = self._values.get("file_path")
        assert result is not None, "Required property 'file_path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def arguments(self) -> typing.Optional[builtins.str]:
        '''The arguments to be passed to the file.

        :default: No arguments are passed to the file.
        '''
        result = self._values.get("arguments")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ExecuteFileOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class FlowLogDestination(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.FlowLogDestination",
):
    '''The destination type for the flow log.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        log_group = logs.LogGroup(self, "MyCustomLogGroup")
        
        role = iam.Role(self, "MyCustomRole",
            assumed_by=iam.ServicePrincipal("vpc-flow-logs.amazonaws.com")
        )
        
        ec2.FlowLog(self, "FlowLog",
            resource_type=ec2.FlowLogResourceType.from_vpc(vpc),
            destination=ec2.FlowLogDestination.to_cloud_watch_logs(log_group, role)
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="toCloudWatchLogs")
    @builtins.classmethod
    def to_cloud_watch_logs(
        cls,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        iam_role: typing.Optional[_IRole_235f5d8e] = None,
    ) -> "FlowLogDestination":
        '''Use CloudWatch logs as the destination.

        :param log_group: -
        :param iam_role: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e81eb717688593829094f61ef25c08b527f0c126ef12a4f4501f14ff1f5cc482)
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            check_type(argname="argument iam_role", value=iam_role, expected_type=type_hints["iam_role"])
        return typing.cast("FlowLogDestination", jsii.sinvoke(cls, "toCloudWatchLogs", [log_group, iam_role]))

    @jsii.member(jsii_name="toKinesisDataFirehoseDestination")
    @builtins.classmethod
    def to_kinesis_data_firehose_destination(
        cls,
        delivery_stream_arn: builtins.str,
    ) -> "FlowLogDestination":
        '''Use Kinesis Data Firehose as the destination.

        :param delivery_stream_arn: the ARN of Kinesis Data Firehose delivery stream to publish logs to.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b3ea932697fa6e2a914a77fa81659cb98c5eed106039fb226a25f275e5820211)
            check_type(argname="argument delivery_stream_arn", value=delivery_stream_arn, expected_type=type_hints["delivery_stream_arn"])
        return typing.cast("FlowLogDestination", jsii.sinvoke(cls, "toKinesisDataFirehoseDestination", [delivery_stream_arn]))

    @jsii.member(jsii_name="toS3")
    @builtins.classmethod
    def to_s3(
        cls,
        bucket: typing.Optional[_IBucket_42e086fd] = None,
        key_prefix: typing.Optional[builtins.str] = None,
        *,
        file_format: typing.Optional["FlowLogFileFormat"] = None,
        hive_compatible_partitions: typing.Optional[builtins.bool] = None,
        per_hour_partition: typing.Optional[builtins.bool] = None,
    ) -> "FlowLogDestination":
        '''Use S3 as the destination.

        :param bucket: optional s3 bucket to publish logs to. If one is not provided a default bucket will be created
        :param key_prefix: optional prefix within the bucket to write logs to.
        :param file_format: The format for the flow log. Default: FlowLogFileFormat.PLAIN_TEXT
        :param hive_compatible_partitions: Use Hive-compatible prefixes for flow logs stored in Amazon S3. Default: false
        :param per_hour_partition: Partition the flow log per hour. Default: false
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79cf07d488e6d092fa437a996f1a5bdfa11272e368448e3cf26aafe3fdaba2a7)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key_prefix", value=key_prefix, expected_type=type_hints["key_prefix"])
        options = S3DestinationOptions(
            file_format=file_format,
            hive_compatible_partitions=hive_compatible_partitions,
            per_hour_partition=per_hour_partition,
        )

        return typing.cast("FlowLogDestination", jsii.sinvoke(cls, "toS3", [bucket, key_prefix, options]))

    @jsii.member(jsii_name="bind")
    @abc.abstractmethod
    def bind(
        self,
        scope: _constructs_77d1e7e8.Construct,
        flow_log: "FlowLog",
    ) -> "FlowLogDestinationConfig":
        '''Generates a flow log destination configuration.

        :param scope: -
        :param flow_log: -
        '''
        ...


class _FlowLogDestinationProxy(FlowLogDestination):
    @jsii.member(jsii_name="bind")
    def bind(
        self,
        scope: _constructs_77d1e7e8.Construct,
        flow_log: "FlowLog",
    ) -> "FlowLogDestinationConfig":
        '''Generates a flow log destination configuration.

        :param scope: -
        :param flow_log: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6de3e83d4f326681c20b1dcb1ee71d599559b05ce0028cfc61d592f89edbfbac)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument flow_log", value=flow_log, expected_type=type_hints["flow_log"])
        return typing.cast("FlowLogDestinationConfig", jsii.invoke(self, "bind", [scope, flow_log]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, FlowLogDestination).__jsii_proxy_class__ = lambda : _FlowLogDestinationProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.FlowLogDestinationConfig",
    jsii_struct_bases=[],
    name_mapping={
        "log_destination_type": "logDestinationType",
        "delivery_stream_arn": "deliveryStreamArn",
        "destination_options": "destinationOptions",
        "iam_role": "iamRole",
        "key_prefix": "keyPrefix",
        "log_group": "logGroup",
        "s3_bucket": "s3Bucket",
    },
)
class FlowLogDestinationConfig:
    def __init__(
        self,
        *,
        log_destination_type: "FlowLogDestinationType",
        delivery_stream_arn: typing.Optional[builtins.str] = None,
        destination_options: typing.Optional[typing.Union["DestinationOptions", typing.Dict[builtins.str, typing.Any]]] = None,
        iam_role: typing.Optional[_IRole_235f5d8e] = None,
        key_prefix: typing.Optional[builtins.str] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        s3_bucket: typing.Optional[_IBucket_42e086fd] = None,
    ) -> None:
        '''Flow Log Destination configuration.

        :param log_destination_type: The type of destination to publish the flow logs to. Default: - CLOUD_WATCH_LOGS
        :param delivery_stream_arn: The ARN of Kinesis Data Firehose delivery stream to publish the flow logs to. Default: - undefined
        :param destination_options: Options for writing flow logs to a supported destination. Default: - undefined
        :param iam_role: The IAM Role that has access to publish to CloudWatch logs. Default: - default IAM role is created for you
        :param key_prefix: S3 bucket key prefix to publish the flow logs to. Default: - undefined
        :param log_group: The CloudWatch Logs Log Group to publish the flow logs to. Default: - default log group is created for you
        :param s3_bucket: S3 bucket to publish the flow logs to. Default: - undefined

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_iam as iam
            from aws_cdk import aws_logs as logs
            from aws_cdk import aws_s3 as s3
            
            # bucket: s3.Bucket
            # log_group: logs.LogGroup
            # role: iam.Role
            
            flow_log_destination_config = ec2.FlowLogDestinationConfig(
                log_destination_type=ec2.FlowLogDestinationType.CLOUD_WATCH_LOGS,
            
                # the properties below are optional
                delivery_stream_arn="deliveryStreamArn",
                destination_options=ec2.DestinationOptions(
                    file_format=ec2.FlowLogFileFormat.PLAIN_TEXT,
                    hive_compatible_partitions=False,
                    per_hour_partition=False
                ),
                iam_role=role,
                key_prefix="keyPrefix",
                log_group=log_group,
                s3_bucket=bucket
            )
        '''
        if isinstance(destination_options, dict):
            destination_options = DestinationOptions(**destination_options)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba6998f7072b44609280cd797e9230fb710a52e9376635e4a577c44a0389bdd6)
            check_type(argname="argument log_destination_type", value=log_destination_type, expected_type=type_hints["log_destination_type"])
            check_type(argname="argument delivery_stream_arn", value=delivery_stream_arn, expected_type=type_hints["delivery_stream_arn"])
            check_type(argname="argument destination_options", value=destination_options, expected_type=type_hints["destination_options"])
            check_type(argname="argument iam_role", value=iam_role, expected_type=type_hints["iam_role"])
            check_type(argname="argument key_prefix", value=key_prefix, expected_type=type_hints["key_prefix"])
            check_type(argname="argument log_group", value=log_group, expected_type=type_hints["log_group"])
            check_type(argname="argument s3_bucket", value=s3_bucket, expected_type=type_hints["s3_bucket"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "log_destination_type": log_destination_type,
        }
        if delivery_stream_arn is not None:
            self._values["delivery_stream_arn"] = delivery_stream_arn
        if destination_options is not None:
            self._values["destination_options"] = destination_options
        if iam_role is not None:
            self._values["iam_role"] = iam_role
        if key_prefix is not None:
            self._values["key_prefix"] = key_prefix
        if log_group is not None:
            self._values["log_group"] = log_group
        if s3_bucket is not None:
            self._values["s3_bucket"] = s3_bucket

    @builtins.property
    def log_destination_type(self) -> "FlowLogDestinationType":
        '''The type of destination to publish the flow logs to.

        :default: - CLOUD_WATCH_LOGS
        '''
        result = self._values.get("log_destination_type")
        assert result is not None, "Required property 'log_destination_type' is missing"
        return typing.cast("FlowLogDestinationType", result)

    @builtins.property
    def delivery_stream_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of Kinesis Data Firehose delivery stream to publish the flow logs to.

        :default: - undefined
        '''
        result = self._values.get("delivery_stream_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def destination_options(self) -> typing.Optional["DestinationOptions"]:
        '''Options for writing flow logs to a supported destination.

        :default: - undefined
        '''
        result = self._values.get("destination_options")
        return typing.cast(typing.Optional["DestinationOptions"], result)

    @builtins.property
    def iam_role(self) -> typing.Optional[_IRole_235f5d8e]:
        '''The IAM Role that has access to publish to CloudWatch logs.

        :default: - default IAM role is created for you
        '''
        result = self._values.get("iam_role")
        return typing.cast(typing.Optional[_IRole_235f5d8e], result)

    @builtins.property
    def key_prefix(self) -> typing.Optional[builtins.str]:
        '''S3 bucket key prefix to publish the flow logs to.

        :default: - undefined
        '''
        result = self._values.get("key_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def log_group(self) -> typing.Optional[_ILogGroup_3c4fa718]:
        '''The CloudWatch Logs Log Group to publish the flow logs to.

        :default: - default log group is created for you
        '''
        result = self._values.get("log_group")
        return typing.cast(typing.Optional[_ILogGroup_3c4fa718], result)

    @builtins.property
    def s3_bucket(self) -> typing.Optional[_IBucket_42e086fd]:
        '''S3 bucket to publish the flow logs to.

        :default: - undefined
        '''
        result = self._values.get("s3_bucket")
        return typing.cast(typing.Optional[_IBucket_42e086fd], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FlowLogDestinationConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.FlowLogDestinationType")
class FlowLogDestinationType(enum.Enum):
    '''The available destination types for Flow Logs.'''

    CLOUD_WATCH_LOGS = "CLOUD_WATCH_LOGS"
    '''Send flow logs to CloudWatch Logs Group.'''
    S3 = "S3"
    '''Send flow logs to S3 Bucket.'''
    KINESIS_DATA_FIREHOSE = "KINESIS_DATA_FIREHOSE"
    '''Send flow logs to Kinesis Data Firehose.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.FlowLogFileFormat")
class FlowLogFileFormat(enum.Enum):
    '''The file format for flow logs written to an S3 bucket destination.'''

    PLAIN_TEXT = "PLAIN_TEXT"
    '''File will be written as plain text.

    This is the default value
    '''
    PARQUET = "PARQUET"
    '''File will be written in parquet format.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.FlowLogMaxAggregationInterval")
class FlowLogMaxAggregationInterval(enum.Enum):
    '''The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "Vpc")
        
        vpc.add_flow_log("FlowLogS3",
            destination=ec2.FlowLogDestination.to_s3()
        )
        
        # Only reject traffic and interval every minute.
        vpc.add_flow_log("FlowLogCloudWatch",
            traffic_type=ec2.FlowLogTrafficType.REJECT,
            max_aggregation_interval=ec2.FlowLogMaxAggregationInterval.ONE_MINUTE
        )
    '''

    ONE_MINUTE = "ONE_MINUTE"
    '''1 minute (60 seconds).'''
    TEN_MINUTES = "TEN_MINUTES"
    '''10 minutes (600 seconds).'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.FlowLogOptions",
    jsii_struct_bases=[],
    name_mapping={
        "destination": "destination",
        "log_format": "logFormat",
        "max_aggregation_interval": "maxAggregationInterval",
        "traffic_type": "trafficType",
    },
)
class FlowLogOptions:
    def __init__(
        self,
        *,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence["LogFormat"]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional["FlowLogTrafficType"] = None,
    ) -> None:
        '''Options to add a flow log to a VPC.

        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL

        :exampleMetadata: infused

        Example::

            vpc = ec2.Vpc(self, "Vpc")
            
            vpc.add_flow_log("FlowLogS3",
                destination=ec2.FlowLogDestination.to_s3()
            )
            
            # Only reject traffic and interval every minute.
            vpc.add_flow_log("FlowLogCloudWatch",
                traffic_type=ec2.FlowLogTrafficType.REJECT,
                max_aggregation_interval=ec2.FlowLogMaxAggregationInterval.ONE_MINUTE
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a08c83d6120105afeb73ec881a412bb9097dd8643c26c0ee0ca8219a30bbd96)
            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
            check_type(argname="argument log_format", value=log_format, expected_type=type_hints["log_format"])
            check_type(argname="argument max_aggregation_interval", value=max_aggregation_interval, expected_type=type_hints["max_aggregation_interval"])
            check_type(argname="argument traffic_type", value=traffic_type, expected_type=type_hints["traffic_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if destination is not None:
            self._values["destination"] = destination
        if log_format is not None:
            self._values["log_format"] = log_format
        if max_aggregation_interval is not None:
            self._values["max_aggregation_interval"] = max_aggregation_interval
        if traffic_type is not None:
            self._values["traffic_type"] = traffic_type

    @builtins.property
    def destination(self) -> typing.Optional[FlowLogDestination]:
        '''Specifies the type of destination to which the flow log data is to be published.

        Flow log data can be published to CloudWatch Logs or Amazon S3

        :default: FlowLogDestinationType.toCloudWatchLogs()
        '''
        result = self._values.get("destination")
        return typing.cast(typing.Optional[FlowLogDestination], result)

    @builtins.property
    def log_format(self) -> typing.Optional[typing.List["LogFormat"]]:
        '''The fields to include in the flow log record, in the order in which they should appear.

        If multiple fields are specified, they will be separated by spaces. For full control over the literal log format
        string, pass a single field constructed with ``LogFormat.custom()``.

        See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records

        :default: - default log format is used.
        '''
        result = self._values.get("log_format")
        return typing.cast(typing.Optional[typing.List["LogFormat"]], result)

    @builtins.property
    def max_aggregation_interval(
        self,
    ) -> typing.Optional[FlowLogMaxAggregationInterval]:
        '''The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record.

        When creating flow logs for a Transit Gateway or Transit Gateway Attachment,
        this property must be ONE_MINUTES.

        :default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-maxaggregationinterval
        '''
        result = self._values.get("max_aggregation_interval")
        return typing.cast(typing.Optional[FlowLogMaxAggregationInterval], result)

    @builtins.property
    def traffic_type(self) -> typing.Optional["FlowLogTrafficType"]:
        '''The type of traffic to log.

        You can log traffic that the resource accepts or rejects, or all traffic.
        When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible.

        :default: ALL

        :see: https://docs.aws.amazon.com/vpc/latest/tgw/working-with-flow-logs.html
        '''
        result = self._values.get("traffic_type")
        return typing.cast(typing.Optional["FlowLogTrafficType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FlowLogOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.FlowLogProps",
    jsii_struct_bases=[FlowLogOptions],
    name_mapping={
        "destination": "destination",
        "log_format": "logFormat",
        "max_aggregation_interval": "maxAggregationInterval",
        "traffic_type": "trafficType",
        "resource_type": "resourceType",
        "flow_log_name": "flowLogName",
    },
)
class FlowLogProps(FlowLogOptions):
    def __init__(
        self,
        *,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence["LogFormat"]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional["FlowLogTrafficType"] = None,
        resource_type: "FlowLogResourceType",
        flow_log_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties of a VPC Flow Log.

        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL
        :param resource_type: The type of resource for which to create the flow log.
        :param flow_log_name: The name of the FlowLog. Since the FlowLog resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag. Default: CDK generated name

        :exampleMetadata: infused

        Example::

            # tgw: ec2.CfnTransitGateway
            
            
            ec2.FlowLog(self, "TransitGatewayFlowLog",
                resource_type=ec2.FlowLogResourceType.from_transit_gateway_id(tgw.ref)
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ca1b8e252416a0e606a3467258ca5d0833010dc7f9219ca1096813a8df530997)
            check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
            check_type(argname="argument log_format", value=log_format, expected_type=type_hints["log_format"])
            check_type(argname="argument max_aggregation_interval", value=max_aggregation_interval, expected_type=type_hints["max_aggregation_interval"])
            check_type(argname="argument traffic_type", value=traffic_type, expected_type=type_hints["traffic_type"])
            check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
            check_type(argname="argument flow_log_name", value=flow_log_name, expected_type=type_hints["flow_log_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "resource_type": resource_type,
        }
        if destination is not None:
            self._values["destination"] = destination
        if log_format is not None:
            self._values["log_format"] = log_format
        if max_aggregation_interval is not None:
            self._values["max_aggregation_interval"] = max_aggregation_interval
        if traffic_type is not None:
            self._values["traffic_type"] = traffic_type
        if flow_log_name is not None:
            self._values["flow_log_name"] = flow_log_name

    @builtins.property
    def destination(self) -> typing.Optional[FlowLogDestination]:
        '''Specifies the type of destination to which the flow log data is to be published.

        Flow log data can be published to CloudWatch Logs or Amazon S3

        :default: FlowLogDestinationType.toCloudWatchLogs()
        '''
        result = self._values.get("destination")
        return typing.cast(typing.Optional[FlowLogDestination], result)

    @builtins.property
    def log_format(self) -> typing.Optional[typing.List["LogFormat"]]:
        '''The fields to include in the flow log record, in the order in which they should appear.

        If multiple fields are specified, they will be separated by spaces. For full control over the literal log format
        string, pass a single field constructed with ``LogFormat.custom()``.

        See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records

        :default: - default log format is used.
        '''
        result = self._values.get("log_format")
        return typing.cast(typing.Optional[typing.List["LogFormat"]], result)

    @builtins.property
    def max_aggregation_interval(
        self,
    ) -> typing.Optional[FlowLogMaxAggregationInterval]:
        '''The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record.

        When creating flow logs for a Transit Gateway or Transit Gateway Attachment,
        this property must be ONE_MINUTES.

        :default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-flowlog.html#cfn-ec2-flowlog-maxaggregationinterval
        '''
        result = self._values.get("max_aggregation_interval")
        return typing.cast(typing.Optional[FlowLogMaxAggregationInterval], result)

    @builtins.property
    def traffic_type(self) -> typing.Optional["FlowLogTrafficType"]:
        '''The type of traffic to log.

        You can log traffic that the resource accepts or rejects, or all traffic.
        When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible.

        :default: ALL

        :see: https://docs.aws.amazon.com/vpc/latest/tgw/working-with-flow-logs.html
        '''
        result = self._values.get("traffic_type")
        return typing.cast(typing.Optional["FlowLogTrafficType"], result)

    @builtins.property
    def resource_type(self) -> "FlowLogResourceType":
        '''The type of resource for which to create the flow log.'''
        result = self._values.get("resource_type")
        assert result is not None, "Required property 'resource_type' is missing"
        return typing.cast("FlowLogResourceType", result)

    @builtins.property
    def flow_log_name(self) -> typing.Optional[builtins.str]:
        '''The name of the FlowLog.

        Since the FlowLog resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag.

        :default: CDK generated name
        '''
        result = self._values.get("flow_log_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FlowLogProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class FlowLogResourceType(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.FlowLogResourceType",
):
    '''The type of resource to create the flow log for.

    :exampleMetadata: infused

    Example::

        # tgw: ec2.CfnTransitGateway
        
        
        ec2.FlowLog(self, "TransitGatewayFlowLog",
            resource_type=ec2.FlowLogResourceType.from_transit_gateway_id(tgw.ref)
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromNetworkInterfaceId")
    @builtins.classmethod
    def from_network_interface_id(cls, id: builtins.str) -> "FlowLogResourceType":
        '''The Network Interface to attach the Flow Log to.

        :param id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a488a320c16fc6456f63c84642c17f7a01175d0dbb8cac1022e6d3c42aa3daa7)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        return typing.cast("FlowLogResourceType", jsii.sinvoke(cls, "fromNetworkInterfaceId", [id]))

    @jsii.member(jsii_name="fromSubnet")
    @builtins.classmethod
    def from_subnet(cls, subnet: "ISubnet") -> "FlowLogResourceType":
        '''The subnet to attach the Flow Log to.

        :param subnet: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76b2df28447c252d4e9f5ca77dd2f8f3b06b2858fda3051bddfa5c5834e0203a)
            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
        return typing.cast("FlowLogResourceType", jsii.sinvoke(cls, "fromSubnet", [subnet]))

    @jsii.member(jsii_name="fromTransitGatewayAttachmentId")
    @builtins.classmethod
    def from_transit_gateway_attachment_id(
        cls,
        id: builtins.str,
    ) -> "FlowLogResourceType":
        '''The Transit Gateway Attachment to attach the Flow Log to.

        :param id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9d7627487ab93066cd2226a249164c563005466f84ef5b134d17cfd2575c2f8)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        return typing.cast("FlowLogResourceType", jsii.sinvoke(cls, "fromTransitGatewayAttachmentId", [id]))

    @jsii.member(jsii_name="fromTransitGatewayId")
    @builtins.classmethod
    def from_transit_gateway_id(cls, id: builtins.str) -> "FlowLogResourceType":
        '''The Transit Gateway to attach the Flow Log to.

        :param id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4252d171c035a2a5753d511aae727f7536b3571e7a9a94317b77df10967bf1b7)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        return typing.cast("FlowLogResourceType", jsii.sinvoke(cls, "fromTransitGatewayId", [id]))

    @jsii.member(jsii_name="fromVpc")
    @builtins.classmethod
    def from_vpc(cls, vpc: "IVpc") -> "FlowLogResourceType":
        '''The VPC to attach the Flow Log to.

        :param vpc: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71ca8111af1b31e7a6b4b9dafacd39309c7272133becbd480d415b8348234308)
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        return typing.cast("FlowLogResourceType", jsii.sinvoke(cls, "fromVpc", [vpc]))

    @builtins.property
    @jsii.member(jsii_name="resourceId")
    @abc.abstractmethod
    def resource_id(self) -> builtins.str:
        '''The Id of the resource that the flow log should be attached to.'''
        ...

    @resource_id.setter
    @abc.abstractmethod
    def resource_id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="resourceType")
    @abc.abstractmethod
    def resource_type(self) -> builtins.str:
        '''The type of resource to attach a flow log to.'''
        ...

    @resource_type.setter
    @abc.abstractmethod
    def resource_type(self, value: builtins.str) -> None:
        ...


class _FlowLogResourceTypeProxy(FlowLogResourceType):
    @builtins.property
    @jsii.member(jsii_name="resourceId")
    def resource_id(self) -> builtins.str:
        '''The Id of the resource that the flow log should be attached to.'''
        return typing.cast(builtins.str, jsii.get(self, "resourceId"))

    @resource_id.setter
    def resource_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f5a45e85453138a588e72b7d2553bac08c85eaa74f42e9e84869c8cf792e354)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "resourceId", value)

    @builtins.property
    @jsii.member(jsii_name="resourceType")
    def resource_type(self) -> builtins.str:
        '''The type of resource to attach a flow log to.'''
        return typing.cast(builtins.str, jsii.get(self, "resourceType"))

    @resource_type.setter
    def resource_type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3d34300fa4a7621691fa63c06d20d8f88586f38f5c58560a2f25eed4efb38515)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "resourceType", value)

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, FlowLogResourceType).__jsii_proxy_class__ = lambda : _FlowLogResourceTypeProxy


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.FlowLogTrafficType")
class FlowLogTrafficType(enum.Enum):
    '''The type of VPC traffic to log.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "Vpc")
        
        vpc.add_flow_log("FlowLogS3",
            destination=ec2.FlowLogDestination.to_s3()
        )
        
        # Only reject traffic and interval every minute.
        vpc.add_flow_log("FlowLogCloudWatch",
            traffic_type=ec2.FlowLogTrafficType.REJECT,
            max_aggregation_interval=ec2.FlowLogMaxAggregationInterval.ONE_MINUTE
        )
    '''

    ACCEPT = "ACCEPT"
    '''Only log accepts.'''
    ALL = "ALL"
    '''Log all requests.'''
    REJECT = "REJECT"
    '''Only log rejects.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.GatewayConfig",
    jsii_struct_bases=[],
    name_mapping={"az": "az", "gateway_id": "gatewayId"},
)
class GatewayConfig:
    def __init__(self, *, az: builtins.str, gateway_id: builtins.str) -> None:
        '''Pair represents a gateway created by NAT Provider.

        :param az: Availability Zone.
        :param gateway_id: Identity of gateway spawned by the provider.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            gateway_config = ec2.GatewayConfig(
                az="az",
                gateway_id="gatewayId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b57cf38071e22f6aa0da293f72825a116e18760fc86d39f8d73ad02cd1f4945)
            check_type(argname="argument az", value=az, expected_type=type_hints["az"])
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "az": az,
            "gateway_id": gateway_id,
        }

    @builtins.property
    def az(self) -> builtins.str:
        '''Availability Zone.'''
        result = self._values.get("az")
        assert result is not None, "Required property 'az' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def gateway_id(self) -> builtins.str:
        '''Identity of gateway spawned by the provider.'''
        result = self._values.get("gateway_id")
        assert result is not None, "Required property 'gateway_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GatewayConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.GatewayVpcEndpointOptions",
    jsii_struct_bases=[],
    name_mapping={"service": "service", "subnets": "subnets"},
)
class GatewayVpcEndpointOptions:
    def __init__(
        self,
        *,
        service: "IGatewayVpcEndpointService",
        subnets: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Options to add a gateway endpoint to a VPC.

        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC

        :exampleMetadata: lit=aws-ec2/test/integ.vpc-endpoint.lit.ts infused

        Example::

            # Add gateway endpoints when creating the VPC
            vpc = ec2.Vpc(self, "MyVpc",
                gateway_endpoints={
                    "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
                        service=ec2.GatewayVpcEndpointAwsService.S3
                    )
                }
            )
            
            # Alternatively gateway endpoints can be added on the VPC
            dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
                service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
            )
            
            # This allows to customize the endpoint policy
            dynamo_db_endpoint.add_to_policy(
                iam.PolicyStatement( # Restrict to listing and describing tables
                    principals=[iam.AnyPrincipal()],
                    actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
                    resources=["*"]))
            
            # Add an interface endpoint
            vpc.add_interface_endpoint("EcrDockerEndpoint",
                service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d9788cc62897d6cd47b25ae688ddfe796bd0ff162f3bedfcb3b05a11efd685c1)
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service": service,
        }
        if subnets is not None:
            self._values["subnets"] = subnets

    @builtins.property
    def service(self) -> "IGatewayVpcEndpointService":
        '''The service to use for this gateway VPC endpoint.'''
        result = self._values.get("service")
        assert result is not None, "Required property 'service' is missing"
        return typing.cast("IGatewayVpcEndpointService", result)

    @builtins.property
    def subnets(self) -> typing.Optional[typing.List["SubnetSelection"]]:
        '''Where to add endpoint routing.

        By default, this endpoint will be routable from all subnets in the VPC.
        Specify a list of subnet selection objects here to be more specific.

        :default: - All subnets in the VPC

        Example::

            # vpc: ec2.Vpc
            
            
            vpc.add_gateway_endpoint("DynamoDbEndpoint",
                service=ec2.GatewayVpcEndpointAwsService.DYNAMODB,
                # Add only to ISOLATED subnets
                subnets=[ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_ISOLATED)
                ]
            )
        '''
        result = self._values.get("subnets")
        return typing.cast(typing.Optional[typing.List["SubnetSelection"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GatewayVpcEndpointOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.GatewayVpcEndpointProps",
    jsii_struct_bases=[GatewayVpcEndpointOptions],
    name_mapping={"service": "service", "subnets": "subnets", "vpc": "vpc"},
)
class GatewayVpcEndpointProps(GatewayVpcEndpointOptions):
    def __init__(
        self,
        *,
        service: "IGatewayVpcEndpointService",
        subnets: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc: "IVpc",
    ) -> None:
        '''Construction properties for a GatewayVpcEndpoint.

        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC
        :param vpc: The VPC network in which the gateway endpoint will be used.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # gateway_vpc_endpoint_service: ec2.IGatewayVpcEndpointService
            # subnet: ec2.Subnet
            # subnet_filter: ec2.SubnetFilter
            # vpc: ec2.Vpc
            
            gateway_vpc_endpoint_props = ec2.GatewayVpcEndpointProps(
                service=gateway_vpc_endpoint_service,
                vpc=vpc,
            
                # the properties below are optional
                subnets=[ec2.SubnetSelection(
                    availability_zones=["availabilityZones"],
                    one_per_az=False,
                    subnet_filters=[subnet_filter],
                    subnet_group_name="subnetGroupName",
                    subnets=[subnet],
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__be3935bf206eb9d190122970d9457b5ace891ba2d8356ccd2fe1959c201afa86)
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service": service,
            "vpc": vpc,
        }
        if subnets is not None:
            self._values["subnets"] = subnets

    @builtins.property
    def service(self) -> "IGatewayVpcEndpointService":
        '''The service to use for this gateway VPC endpoint.'''
        result = self._values.get("service")
        assert result is not None, "Required property 'service' is missing"
        return typing.cast("IGatewayVpcEndpointService", result)

    @builtins.property
    def subnets(self) -> typing.Optional[typing.List["SubnetSelection"]]:
        '''Where to add endpoint routing.

        By default, this endpoint will be routable from all subnets in the VPC.
        Specify a list of subnet selection objects here to be more specific.

        :default: - All subnets in the VPC

        Example::

            # vpc: ec2.Vpc
            
            
            vpc.add_gateway_endpoint("DynamoDbEndpoint",
                service=ec2.GatewayVpcEndpointAwsService.DYNAMODB,
                # Add only to ISOLATED subnets
                subnets=[ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE_ISOLATED)
                ]
            )
        '''
        result = self._values.get("subnets")
        return typing.cast(typing.Optional[typing.List["SubnetSelection"]], result)

    @builtins.property
    def vpc(self) -> "IVpc":
        '''The VPC network in which the gateway endpoint will be used.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast("IVpc", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GatewayVpcEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.GenericLinuxImageProps",
    jsii_struct_bases=[],
    name_mapping={"user_data": "userData"},
)
class GenericLinuxImageProps:
    def __init__(self, *, user_data: typing.Optional["UserData"] = None) -> None:
        '''Configuration options for GenericLinuxImage.

        :param user_data: Initial user data. Default: - Empty UserData for Linux machines

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            generic_linux_image_props = ec2.GenericLinuxImageProps(
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cdec605761ae5397bea8594fe22514ce56475e36caaa69aa05dba865d23cad4a)
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GenericLinuxImageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.GenericWindowsImageProps",
    jsii_struct_bases=[],
    name_mapping={"user_data": "userData"},
)
class GenericWindowsImageProps:
    def __init__(self, *, user_data: typing.Optional["UserData"] = None) -> None:
        '''Configuration options for GenericWindowsImage.

        :param user_data: Initial user data. Default: - Empty UserData for Windows machines

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            generic_windows_image_props = ec2.GenericWindowsImageProps(
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6a8b65cfba9b4c22d0d25b80ef337d1fa4bcc5218fbcafc44f0550a54dea5089)
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Initial user data.

        :default: - Empty UserData for Windows machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GenericWindowsImageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IClientVpnConnectionHandler")
class IClientVpnConnectionHandler(typing_extensions.Protocol):
    '''A connection handler for client VPN endpoints.'''

    @builtins.property
    @jsii.member(jsii_name="functionArn")
    def function_arn(self) -> builtins.str:
        '''The ARN of the function.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="functionName")
    def function_name(self) -> builtins.str:
        '''The name of the function.'''
        ...


class _IClientVpnConnectionHandlerProxy:
    '''A connection handler for client VPN endpoints.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IClientVpnConnectionHandler"

    @builtins.property
    @jsii.member(jsii_name="functionArn")
    def function_arn(self) -> builtins.str:
        '''The ARN of the function.'''
        return typing.cast(builtins.str, jsii.get(self, "functionArn"))

    @builtins.property
    @jsii.member(jsii_name="functionName")
    def function_name(self) -> builtins.str:
        '''The name of the function.'''
        return typing.cast(builtins.str, jsii.get(self, "functionName"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IClientVpnConnectionHandler).__jsii_proxy_class__ = lambda : _IClientVpnConnectionHandlerProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IConnectable")
class IConnectable(typing_extensions.Protocol):
    '''An object that has a Connections object.'''

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''The network connections associated with this resource.'''
        ...


class _IConnectableProxy:
    '''An object that has a Connections object.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IConnectable"

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''The network connections associated with this resource.'''
        return typing.cast("Connections", jsii.get(self, "connections"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IConnectable).__jsii_proxy_class__ = lambda : _IConnectableProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IFlowLog")
class IFlowLog(_IResource_c80c4260, typing_extensions.Protocol):
    '''A FlowLog.'''

    @builtins.property
    @jsii.member(jsii_name="flowLogId")
    def flow_log_id(self) -> builtins.str:
        '''The Id of the VPC Flow Log.

        :attribute: true
        '''
        ...


class _IFlowLogProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A FlowLog.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IFlowLog"

    @builtins.property
    @jsii.member(jsii_name="flowLogId")
    def flow_log_id(self) -> builtins.str:
        '''The Id of the VPC Flow Log.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "flowLogId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IFlowLog).__jsii_proxy_class__ = lambda : _IFlowLogProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IGatewayVpcEndpointService")
class IGatewayVpcEndpointService(typing_extensions.Protocol):
    '''A service for a gateway VPC endpoint.'''

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        ...


class _IGatewayVpcEndpointServiceProxy:
    '''A service for a gateway VPC endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IGatewayVpcEndpointService"

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IGatewayVpcEndpointService).__jsii_proxy_class__ = lambda : _IGatewayVpcEndpointServiceProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IInstance")
class IInstance(
    _IResource_c80c4260,
    IConnectable,
    _IGrantable_71c4f5de,
    typing_extensions.Protocol,
):
    @builtins.property
    @jsii.member(jsii_name="instanceAvailabilityZone")
    def instance_availability_zone(self) -> builtins.str:
        '''The availability zone the instance was launched in.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The instance's ID.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="instancePrivateDnsName")
    def instance_private_dns_name(self) -> builtins.str:
        '''Private DNS name for this instance.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="instancePrivateIp")
    def instance_private_ip(self) -> builtins.str:
        '''Private IP for this instance.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="instancePublicDnsName")
    def instance_public_dns_name(self) -> builtins.str:
        '''Publicly-routable DNS name for this instance.

        (May be an empty string if the instance does not have a public name).

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="instancePublicIp")
    def instance_public_ip(self) -> builtins.str:
        '''Publicly-routable IP  address for this instance.

        (May be an empty string if the instance does not have a public IP).

        :attribute: true
        '''
        ...


class _IInstanceProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
    jsii.proxy_for(IConnectable), # type: ignore[misc]
    jsii.proxy_for(_IGrantable_71c4f5de), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IInstance"

    @builtins.property
    @jsii.member(jsii_name="instanceAvailabilityZone")
    def instance_availability_zone(self) -> builtins.str:
        '''The availability zone the instance was launched in.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The instance's ID.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceId"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateDnsName")
    def instance_private_dns_name(self) -> builtins.str:
        '''Private DNS name for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateIp")
    def instance_private_ip(self) -> builtins.str:
        '''Private IP for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateIp"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicDnsName")
    def instance_public_dns_name(self) -> builtins.str:
        '''Publicly-routable DNS name for this instance.

        (May be an empty string if the instance does not have a public name).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicIp")
    def instance_public_ip(self) -> builtins.str:
        '''Publicly-routable IP  address for this instance.

        (May be an empty string if the instance does not have a public IP).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicIp"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInstance).__jsii_proxy_class__ = lambda : _IInstanceProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IInterfaceVpcEndpointService")
class IInterfaceVpcEndpointService(typing_extensions.Protocol):
    '''A service for an interface VPC endpoint.'''

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="port")
    def port(self) -> jsii.Number:
        '''The port of the service.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="privateDnsDefault")
    def private_dns_default(self) -> typing.Optional[builtins.bool]:
        '''Whether Private DNS is supported by default.'''
        ...


class _IInterfaceVpcEndpointServiceProxy:
    '''A service for an interface VPC endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IInterfaceVpcEndpointService"

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="port")
    def port(self) -> jsii.Number:
        '''The port of the service.'''
        return typing.cast(jsii.Number, jsii.get(self, "port"))

    @builtins.property
    @jsii.member(jsii_name="privateDnsDefault")
    def private_dns_default(self) -> typing.Optional[builtins.bool]:
        '''Whether Private DNS is supported by default.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "privateDnsDefault"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInterfaceVpcEndpointService).__jsii_proxy_class__ = lambda : _IInterfaceVpcEndpointServiceProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IIpAddresses")
class IIpAddresses(typing_extensions.Protocol):
    '''Implementations for ip address management.

    Note this is specific to the IPv4 CIDR.
    '''

    @jsii.member(jsii_name="allocateSubnetsCidr")
    def allocate_subnets_cidr(
        self,
        *,
        requested_subnets: typing.Sequence[typing.Union["RequestedSubnet", typing.Dict[builtins.str, typing.Any]]],
        vpc_cidr: builtins.str,
    ) -> "SubnetIpamOptions":
        '''Called by the VPC to retrieve Subnet options from the Ipam.

        Don't call this directly, the VPC will call it automatically.

        :param requested_subnets: The Subnets to be allocated.
        :param vpc_cidr: The IPv4 CIDR block for this Vpc.
        '''
        ...

    @jsii.member(jsii_name="allocateVpcCidr")
    def allocate_vpc_cidr(self) -> "VpcIpamOptions":
        '''Called by the VPC to retrieve VPC options from the Ipam.

        Don't call this directly, the VPC will call it automatically.
        '''
        ...


class _IIpAddressesProxy:
    '''Implementations for ip address management.

    Note this is specific to the IPv4 CIDR.
    '''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IIpAddresses"

    @jsii.member(jsii_name="allocateSubnetsCidr")
    def allocate_subnets_cidr(
        self,
        *,
        requested_subnets: typing.Sequence[typing.Union["RequestedSubnet", typing.Dict[builtins.str, typing.Any]]],
        vpc_cidr: builtins.str,
    ) -> "SubnetIpamOptions":
        '''Called by the VPC to retrieve Subnet options from the Ipam.

        Don't call this directly, the VPC will call it automatically.

        :param requested_subnets: The Subnets to be allocated.
        :param vpc_cidr: The IPv4 CIDR block for this Vpc.
        '''
        input = AllocateCidrRequest(
            requested_subnets=requested_subnets, vpc_cidr=vpc_cidr
        )

        return typing.cast("SubnetIpamOptions", jsii.invoke(self, "allocateSubnetsCidr", [input]))

    @jsii.member(jsii_name="allocateVpcCidr")
    def allocate_vpc_cidr(self) -> "VpcIpamOptions":
        '''Called by the VPC to retrieve VPC options from the Ipam.

        Don't call this directly, the VPC will call it automatically.
        '''
        return typing.cast("VpcIpamOptions", jsii.invoke(self, "allocateVpcCidr", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IIpAddresses).__jsii_proxy_class__ = lambda : _IIpAddressesProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IIpv6Addresses")
class IIpv6Addresses(typing_extensions.Protocol):
    '''Implementations for IPv6 address management.

    Note this is specific to the IPv6 CIDR.
    '''

    @builtins.property
    @jsii.member(jsii_name="amazonProvided")
    def amazon_provided(self) -> builtins.bool:
        '''Whether the IPv6 CIDR is Amazon provided or not.

        Note this is specific to the IPv6 CIDR.
        '''
        ...

    @amazon_provided.setter
    def amazon_provided(self, value: builtins.bool) -> None:
        ...

    @jsii.member(jsii_name="allocateSubnetsIpv6Cidr")
    def allocate_subnets_ipv6_cidr(
        self,
        *,
        allocated_subnets: typing.Sequence[typing.Union[AllocatedSubnet, typing.Dict[builtins.str, typing.Any]]],
        ipv6_cidrs: typing.Sequence[builtins.str],
    ) -> "SubnetIpamOptions":
        '''Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.

        Note this is specific to the IPv6 CIDR.

        :param allocated_subnets: List of subnets allocated with IPv4 CIDRs.
        :param ipv6_cidrs: The IPv6 CIDRs to be allocated to the subnets.
        '''
        ...

    @jsii.member(jsii_name="allocateVpcIpv6Cidr")
    def allocate_vpc_ipv6_cidr(
        self,
        *,
        scope: _constructs_77d1e7e8.Construct,
        vpc_id: builtins.str,
    ) -> CfnVPCCidrBlock:
        '''Called by VPC to allocate IPv6 CIDR.

        Note this is specific to the IPv6 CIDR.

        :param scope: The VPC construct to attach to.
        :param vpc_id: The id of the VPC.
        '''
        ...

    @jsii.member(jsii_name="createIpv6CidrBlocks")
    def create_ipv6_cidr_blocks(
        self,
        *,
        ipv6_selected_cidr: builtins.str,
        subnet_count: jsii.Number,
        size_mask: typing.Optional[builtins.str] = None,
    ) -> typing.List[builtins.str]:
        '''Split IPv6 CIDR block up for subnets.

        Note this is specific to the IPv6 CIDR.

        :param ipv6_selected_cidr: The IPv6 CIDR block string representation.
        :param subnet_count: The number of subnets to assign CIDRs to.
        :param size_mask: Size of the covered bits in the CIDR. Default: - 128 - 64 = /64 CIDR.
        '''
        ...


class _IIpv6AddressesProxy:
    '''Implementations for IPv6 address management.

    Note this is specific to the IPv6 CIDR.
    '''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IIpv6Addresses"

    @builtins.property
    @jsii.member(jsii_name="amazonProvided")
    def amazon_provided(self) -> builtins.bool:
        '''Whether the IPv6 CIDR is Amazon provided or not.

        Note this is specific to the IPv6 CIDR.
        '''
        return typing.cast(builtins.bool, jsii.get(self, "amazonProvided"))

    @amazon_provided.setter
    def amazon_provided(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb1a5b24515126d4cc13cb8fa4eb61ede7623f86bef6a5e2eaaa137acd37b531)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "amazonProvided", value)

    @jsii.member(jsii_name="allocateSubnetsIpv6Cidr")
    def allocate_subnets_ipv6_cidr(
        self,
        *,
        allocated_subnets: typing.Sequence[typing.Union[AllocatedSubnet, typing.Dict[builtins.str, typing.Any]]],
        ipv6_cidrs: typing.Sequence[builtins.str],
    ) -> "SubnetIpamOptions":
        '''Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.

        Note this is specific to the IPv6 CIDR.

        :param allocated_subnets: List of subnets allocated with IPv4 CIDRs.
        :param ipv6_cidrs: The IPv6 CIDRs to be allocated to the subnets.
        '''
        input = AllocateIpv6CidrRequest(
            allocated_subnets=allocated_subnets, ipv6_cidrs=ipv6_cidrs
        )

        return typing.cast("SubnetIpamOptions", jsii.invoke(self, "allocateSubnetsIpv6Cidr", [input]))

    @jsii.member(jsii_name="allocateVpcIpv6Cidr")
    def allocate_vpc_ipv6_cidr(
        self,
        *,
        scope: _constructs_77d1e7e8.Construct,
        vpc_id: builtins.str,
    ) -> CfnVPCCidrBlock:
        '''Called by VPC to allocate IPv6 CIDR.

        Note this is specific to the IPv6 CIDR.

        :param scope: The VPC construct to attach to.
        :param vpc_id: The id of the VPC.
        '''
        input = AllocateVpcIpv6CidrRequest(scope=scope, vpc_id=vpc_id)

        return typing.cast(CfnVPCCidrBlock, jsii.invoke(self, "allocateVpcIpv6Cidr", [input]))

    @jsii.member(jsii_name="createIpv6CidrBlocks")
    def create_ipv6_cidr_blocks(
        self,
        *,
        ipv6_selected_cidr: builtins.str,
        subnet_count: jsii.Number,
        size_mask: typing.Optional[builtins.str] = None,
    ) -> typing.List[builtins.str]:
        '''Split IPv6 CIDR block up for subnets.

        Note this is specific to the IPv6 CIDR.

        :param ipv6_selected_cidr: The IPv6 CIDR block string representation.
        :param subnet_count: The number of subnets to assign CIDRs to.
        :param size_mask: Size of the covered bits in the CIDR. Default: - 128 - 64 = /64 CIDR.
        '''
        input = CreateIpv6CidrBlocksRequest(
            ipv6_selected_cidr=ipv6_selected_cidr,
            subnet_count=subnet_count,
            size_mask=size_mask,
        )

        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "createIpv6CidrBlocks", [input]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IIpv6Addresses).__jsii_proxy_class__ = lambda : _IIpv6AddressesProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IKeyPair")
class IKeyPair(_IResource_c80c4260, typing_extensions.Protocol):
    '''An EC2 Key Pair.'''

    @builtins.property
    @jsii.member(jsii_name="keyPairName")
    def key_pair_name(self) -> builtins.str:
        '''The name of the key pair.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> typing.Optional["KeyPairType"]:
        '''The type of the key pair.'''
        ...


class _IKeyPairProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''An EC2 Key Pair.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IKeyPair"

    @builtins.property
    @jsii.member(jsii_name="keyPairName")
    def key_pair_name(self) -> builtins.str:
        '''The name of the key pair.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "keyPairName"))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> typing.Optional["KeyPairType"]:
        '''The type of the key pair.'''
        return typing.cast(typing.Optional["KeyPairType"], jsii.get(self, "type"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IKeyPair).__jsii_proxy_class__ = lambda : _IKeyPairProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.ILaunchTemplate")
class ILaunchTemplate(_IResource_c80c4260, typing_extensions.Protocol):
    '''Interface for LaunchTemplate-like objects.'''

    @builtins.property
    @jsii.member(jsii_name="versionNumber")
    def version_number(self) -> builtins.str:
        '''The version number of this launch template to use.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="launchTemplateId")
    def launch_template_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="launchTemplateName")
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''The name of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.

        :attribute: true
        '''
        ...


class _ILaunchTemplateProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''Interface for LaunchTemplate-like objects.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.ILaunchTemplate"

    @builtins.property
    @jsii.member(jsii_name="versionNumber")
    def version_number(self) -> builtins.str:
        '''The version number of this launch template to use.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "versionNumber"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateId")
    def launch_template_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.

        :attribute: true
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "launchTemplateId"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateName")
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''The name of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.

        :attribute: true
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "launchTemplateName"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ILaunchTemplate).__jsii_proxy_class__ = lambda : _ILaunchTemplateProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IMachineImage")
class IMachineImage(typing_extensions.Protocol):
    '''Interface for classes that can select an appropriate machine image to use.'''

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> "MachineImageConfig":
        '''Return the image to use in the given context.

        :param scope: -
        '''
        ...


class _IMachineImageProxy:
    '''Interface for classes that can select an appropriate machine image to use.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IMachineImage"

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> "MachineImageConfig":
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7a08c4179ae7228d55fc6cba81b9eb3e42e3720e4e0a43763e798855d612aece)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("MachineImageConfig", jsii.invoke(self, "getImage", [scope]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IMachineImage).__jsii_proxy_class__ = lambda : _IMachineImageProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.INetworkAcl")
class INetworkAcl(_IResource_c80c4260, typing_extensions.Protocol):
    '''A NetworkAcl.'''

    @builtins.property
    @jsii.member(jsii_name="networkAclId")
    def network_acl_id(self) -> builtins.str:
        '''ID for the current Network ACL.

        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="addEntry")
    def add_entry(
        self,
        id: builtins.str,
        *,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
    ) -> "NetworkAclEntry":
        '''Add a new entry to the ACL.

        :param id: -
        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW
        '''
        ...


class _INetworkAclProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A NetworkAcl.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.INetworkAcl"

    @builtins.property
    @jsii.member(jsii_name="networkAclId")
    def network_acl_id(self) -> builtins.str:
        '''ID for the current Network ACL.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "networkAclId"))

    @jsii.member(jsii_name="addEntry")
    def add_entry(
        self,
        id: builtins.str,
        *,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
    ) -> "NetworkAclEntry":
        '''Add a new entry to the ACL.

        :param id: -
        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__722833841a526e50a0733e3c60dbe25042aa0bae5f690dcc002306163e17ce38)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = CommonNetworkAclEntryOptions(
            cidr=cidr,
            rule_number=rule_number,
            traffic=traffic,
            direction=direction,
            network_acl_entry_name=network_acl_entry_name,
            rule_action=rule_action,
        )

        return typing.cast("NetworkAclEntry", jsii.invoke(self, "addEntry", [id, options]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INetworkAcl).__jsii_proxy_class__ = lambda : _INetworkAclProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.INetworkAclEntry")
class INetworkAclEntry(_IResource_c80c4260, typing_extensions.Protocol):
    '''A NetworkAclEntry.'''

    @builtins.property
    @jsii.member(jsii_name="networkAcl")
    def network_acl(self) -> INetworkAcl:
        '''The network ACL.'''
        ...


class _INetworkAclEntryProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A NetworkAclEntry.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.INetworkAclEntry"

    @builtins.property
    @jsii.member(jsii_name="networkAcl")
    def network_acl(self) -> INetworkAcl:
        '''The network ACL.'''
        return typing.cast(INetworkAcl, jsii.get(self, "networkAcl"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INetworkAclEntry).__jsii_proxy_class__ = lambda : _INetworkAclEntryProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IPeer")
class IPeer(IConnectable, typing_extensions.Protocol):
    '''Interface for classes that provide the peer-specification parts of a security group rule.'''

    @builtins.property
    @jsii.member(jsii_name="canInlineRule")
    def can_inline_rule(self) -> builtins.bool:
        '''Whether the rule can be inlined into a SecurityGroup or not.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="uniqueId")
    def unique_id(self) -> builtins.str:
        '''A unique identifier for this connection peer.'''
        ...

    @jsii.member(jsii_name="toEgressRuleConfig")
    def to_egress_rule_config(self) -> typing.Any:
        '''Produce the egress rule JSON for the given connection.'''
        ...

    @jsii.member(jsii_name="toIngressRuleConfig")
    def to_ingress_rule_config(self) -> typing.Any:
        '''Produce the ingress rule JSON for the given connection.'''
        ...


class _IPeerProxy(
    jsii.proxy_for(IConnectable), # type: ignore[misc]
):
    '''Interface for classes that provide the peer-specification parts of a security group rule.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IPeer"

    @builtins.property
    @jsii.member(jsii_name="canInlineRule")
    def can_inline_rule(self) -> builtins.bool:
        '''Whether the rule can be inlined into a SecurityGroup or not.'''
        return typing.cast(builtins.bool, jsii.get(self, "canInlineRule"))

    @builtins.property
    @jsii.member(jsii_name="uniqueId")
    def unique_id(self) -> builtins.str:
        '''A unique identifier for this connection peer.'''
        return typing.cast(builtins.str, jsii.get(self, "uniqueId"))

    @jsii.member(jsii_name="toEgressRuleConfig")
    def to_egress_rule_config(self) -> typing.Any:
        '''Produce the egress rule JSON for the given connection.'''
        return typing.cast(typing.Any, jsii.invoke(self, "toEgressRuleConfig", []))

    @jsii.member(jsii_name="toIngressRuleConfig")
    def to_ingress_rule_config(self) -> typing.Any:
        '''Produce the ingress rule JSON for the given connection.'''
        return typing.cast(typing.Any, jsii.invoke(self, "toIngressRuleConfig", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPeer).__jsii_proxy_class__ = lambda : _IPeerProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IPlacementGroup")
class IPlacementGroup(_IResource_c80c4260, typing_extensions.Protocol):
    '''Determines where your instances are placed on the underlying hardware according to the specified PlacementGroupStrategy.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
    '''

    @builtins.property
    @jsii.member(jsii_name="placementGroupName")
    def placement_group_name(self) -> builtins.str:
        '''The name of this placement group.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="partitions")
    def partitions(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.

        Valid only when Strategy is set to PARTITION.

        :default: 0
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="spreadLevel")
    def spread_level(self) -> typing.Optional["PlacementGroupSpreadLevel"]:
        '''Places instances on distinct hardware.

        Spread placement groups are recommended for applications
        that have a small number of critical instances that should be kept separate from each other.
        Launching instances in a spread level placement group reduces the risk of simultaneous failures
        that might occur when instances share the same equipment.
        Spread level placement groups provide access to distinct hardware,
        and are therefore suitable for mixing instance types or launching instances over time.
        If you start or launch an instance in a spread placement group and there is insufficient
        unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware
        available over time, so you can try your request again later.
        Placement groups can spread instances across racks or hosts.
        You can use host level spread placement groups only with AWS Outposts.

        :default: - no spread level
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def strategy(self) -> typing.Optional["PlacementGroupStrategy"]:
        '''Which strategy to use when launching instances.

        :default: - ``PlacementGroupStrategy.PARTITION`` if ``partitions`` is defined, ``CLUSTER`` otherwise
        '''
        ...


class _IPlacementGroupProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''Determines where your instances are placed on the underlying hardware according to the specified PlacementGroupStrategy.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
    '''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IPlacementGroup"

    @builtins.property
    @jsii.member(jsii_name="placementGroupName")
    def placement_group_name(self) -> builtins.str:
        '''The name of this placement group.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "placementGroupName"))

    @builtins.property
    @jsii.member(jsii_name="partitions")
    def partitions(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.

        Valid only when Strategy is set to PARTITION.

        :default: 0
        '''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "partitions"))

    @builtins.property
    @jsii.member(jsii_name="spreadLevel")
    def spread_level(self) -> typing.Optional["PlacementGroupSpreadLevel"]:
        '''Places instances on distinct hardware.

        Spread placement groups are recommended for applications
        that have a small number of critical instances that should be kept separate from each other.
        Launching instances in a spread level placement group reduces the risk of simultaneous failures
        that might occur when instances share the same equipment.
        Spread level placement groups provide access to distinct hardware,
        and are therefore suitable for mixing instance types or launching instances over time.
        If you start or launch an instance in a spread placement group and there is insufficient
        unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware
        available over time, so you can try your request again later.
        Placement groups can spread instances across racks or hosts.
        You can use host level spread placement groups only with AWS Outposts.

        :default: - no spread level
        '''
        return typing.cast(typing.Optional["PlacementGroupSpreadLevel"], jsii.get(self, "spreadLevel"))

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def strategy(self) -> typing.Optional["PlacementGroupStrategy"]:
        '''Which strategy to use when launching instances.

        :default: - ``PlacementGroupStrategy.PARTITION`` if ``partitions`` is defined, ``CLUSTER`` otherwise
        '''
        return typing.cast(typing.Optional["PlacementGroupStrategy"], jsii.get(self, "strategy"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPlacementGroup).__jsii_proxy_class__ = lambda : _IPlacementGroupProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IPrefixList")
class IPrefixList(_IResource_c80c4260, typing_extensions.Protocol):
    '''A prefix list.'''

    @builtins.property
    @jsii.member(jsii_name="prefixListId")
    def prefix_list_id(self) -> builtins.str:
        '''The ID of the prefix list.

        :attribute: true
        '''
        ...


class _IPrefixListProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A prefix list.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IPrefixList"

    @builtins.property
    @jsii.member(jsii_name="prefixListId")
    def prefix_list_id(self) -> builtins.str:
        '''The ID of the prefix list.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "prefixListId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPrefixList).__jsii_proxy_class__ = lambda : _IPrefixListProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IRouteTable")
class IRouteTable(typing_extensions.Protocol):
    '''An abstract route table.'''

    @builtins.property
    @jsii.member(jsii_name="routeTableId")
    def route_table_id(self) -> builtins.str:
        '''Route table ID.'''
        ...


class _IRouteTableProxy:
    '''An abstract route table.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IRouteTable"

    @builtins.property
    @jsii.member(jsii_name="routeTableId")
    def route_table_id(self) -> builtins.str:
        '''Route table ID.'''
        return typing.cast(builtins.str, jsii.get(self, "routeTableId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IRouteTable).__jsii_proxy_class__ = lambda : _IRouteTableProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.ISecurityGroup")
class ISecurityGroup(_IResource_c80c4260, IPeer, typing_extensions.Protocol):
    '''Interface for security group-like objects.'''

    @builtins.property
    @jsii.member(jsii_name="allowAllOutbound")
    def allow_all_outbound(self) -> builtins.bool:
        '''Whether the SecurityGroup has been configured to allow all outbound traffic.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="securityGroupId")
    def security_group_id(self) -> builtins.str:
        '''ID for the current security group.

        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="addEgressRule")
    def add_egress_rule(
        self,
        peer: IPeer,
        connection: "Port",
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an egress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        ...

    @jsii.member(jsii_name="addIngressRule")
    def add_ingress_rule(
        self,
        peer: IPeer,
        connection: "Port",
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an ingress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        ...


class _ISecurityGroupProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
    jsii.proxy_for(IPeer), # type: ignore[misc]
):
    '''Interface for security group-like objects.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.ISecurityGroup"

    @builtins.property
    @jsii.member(jsii_name="allowAllOutbound")
    def allow_all_outbound(self) -> builtins.bool:
        '''Whether the SecurityGroup has been configured to allow all outbound traffic.'''
        return typing.cast(builtins.bool, jsii.get(self, "allowAllOutbound"))

    @builtins.property
    @jsii.member(jsii_name="securityGroupId")
    def security_group_id(self) -> builtins.str:
        '''ID for the current security group.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "securityGroupId"))

    @jsii.member(jsii_name="addEgressRule")
    def add_egress_rule(
        self,
        peer: IPeer,
        connection: "Port",
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an egress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7958cf495af025dbfadcc5329145f18a4938eec2f36f8a9f026a0ccdd42c5aa2)
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument remote_rule", value=remote_rule, expected_type=type_hints["remote_rule"])
        return typing.cast(None, jsii.invoke(self, "addEgressRule", [peer, connection, description, remote_rule]))

    @jsii.member(jsii_name="addIngressRule")
    def add_ingress_rule(
        self,
        peer: IPeer,
        connection: "Port",
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an ingress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b9d9655d432f001be225e968886d7511e46b49b3f5d7cfd940f4512ebbe5dec)
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument remote_rule", value=remote_rule, expected_type=type_hints["remote_rule"])
        return typing.cast(None, jsii.invoke(self, "addIngressRule", [peer, connection, description, remote_rule]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISecurityGroup).__jsii_proxy_class__ = lambda : _ISecurityGroupProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.ISubnet")
class ISubnet(_IResource_c80c4260, typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone the subnet is located in.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force internet connectivity established on the VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="ipv4CidrBlock")
    def ipv4_cidr_block(self) -> builtins.str:
        '''The IPv4 CIDR block for this subnet.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="routeTable")
    def route_table(self) -> IRouteTable:
        '''The route table for this subnet.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.

        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="associateNetworkAcl")
    def associate_network_acl(self, id: builtins.str, acl: INetworkAcl) -> None:
        '''Associate a Network ACL with this subnet.

        :param id: -
        :param acl: The Network ACL to associate.
        '''
        ...


class _ISubnetProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.ISubnet"

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone the subnet is located in.'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force internet connectivity established on the VPC.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "internetConnectivityEstablished"))

    @builtins.property
    @jsii.member(jsii_name="ipv4CidrBlock")
    def ipv4_cidr_block(self) -> builtins.str:
        '''The IPv4 CIDR block for this subnet.'''
        return typing.cast(builtins.str, jsii.get(self, "ipv4CidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="routeTable")
    def route_table(self) -> IRouteTable:
        '''The route table for this subnet.'''
        return typing.cast(IRouteTable, jsii.get(self, "routeTable"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @jsii.member(jsii_name="associateNetworkAcl")
    def associate_network_acl(self, id: builtins.str, acl: INetworkAcl) -> None:
        '''Associate a Network ACL with this subnet.

        :param id: -
        :param acl: The Network ACL to associate.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__635c8e8063b1c2ee4ab6c10c91a7641b19ea96bc6b9ccb58b655d816854eb9a6)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
        return typing.cast(None, jsii.invoke(self, "associateNetworkAcl", [id, acl]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISubnet).__jsii_proxy_class__ = lambda : _ISubnetProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.ISubnetNetworkAclAssociation")
class ISubnetNetworkAclAssociation(_IResource_c80c4260, typing_extensions.Protocol):
    '''A SubnetNetworkAclAssociation.'''

    @builtins.property
    @jsii.member(jsii_name="subnetNetworkAclAssociationAssociationId")
    def subnet_network_acl_association_association_id(self) -> builtins.str:
        '''ID for the current SubnetNetworkAclAssociation.

        :attribute: true
        '''
        ...


class _ISubnetNetworkAclAssociationProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A SubnetNetworkAclAssociation.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.ISubnetNetworkAclAssociation"

    @builtins.property
    @jsii.member(jsii_name="subnetNetworkAclAssociationAssociationId")
    def subnet_network_acl_association_association_id(self) -> builtins.str:
        '''ID for the current SubnetNetworkAclAssociation.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetNetworkAclAssociationAssociationId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISubnetNetworkAclAssociation).__jsii_proxy_class__ = lambda : _ISubnetNetworkAclAssociationProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVolume")
class IVolume(_IResource_c80c4260, typing_extensions.Protocol):
    '''An EBS Volume in AWS EC2.'''

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The availability zone that the EBS Volume is contained within (ex: us-west-2a).'''
        ...

    @builtins.property
    @jsii.member(jsii_name="volumeId")
    def volume_id(self) -> builtins.str:
        '''The EBS Volume's ID.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="encryptionKey")
    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The customer-managed encryption key that is used to encrypt the Volume.

        :attribute: true
        '''
        ...

    @jsii.member(jsii_name="grantAttachVolume")
    def grant_attach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach this Volume to an instance.

        CAUTION: Granting an instance permission to attach to itself using this method will lead to
        an unresolvable circular reference between the instance role and the instance.
        Use ``IVolume.grantAttachVolumeToSelf`` to grant an instance permission to attach this
        volume to itself.

        :param grantee: the principal being granted permission.
        :param instances: the instances to which permission is being granted to attach this volume to. If not specified, then permission is granted to attach to all instances in this account.
        '''
        ...

    @jsii.member(jsii_name="grantAttachVolumeByResourceTag")
    def grant_attach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach the Volume by a ResourceTag condition.

        If you are looking to
        grant an Instance, AutoScalingGroup, EC2-Fleet, SpotFleet, ECS host, etc the ability to attach
        this volume to **itself** then this is the method you want to use.

        This is implemented by adding a Tag with key ``VolumeGrantAttach-<suffix>`` to the given
        constructs and this Volume, and then conditioning the Grant such that the grantee is only
        given the ability to AttachVolume if both the Volume and the destination Instance have that
        tag applied to them.

        :param grantee: the principal being granted permission.
        :param constructs: The list of constructs that will have the generated resource tag applied to them.
        :param tag_key_suffix: A suffix to use on the generated Tag key in place of the generated hash value. Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)
        '''
        ...

    @jsii.member(jsii_name="grantDetachVolume")
    def grant_detach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach this Volume from an instance CAUTION: Granting an instance permission to detach from itself using this method will lead to an unresolvable circular reference between the instance role and the instance.

        Use ``IVolume.grantDetachVolumeFromSelf`` to grant an instance permission to detach this
        volume from itself.

        :param grantee: the principal being granted permission.
        :param instances: the instances to which permission is being granted to detach this volume from. If not specified, then permission is granted to detach from all instances in this account.
        '''
        ...

    @jsii.member(jsii_name="grantDetachVolumeByResourceTag")
    def grant_detach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach the Volume by a ResourceTag condition.

        This is implemented via the same mechanism as ``IVolume.grantAttachVolumeByResourceTag``,
        and is subject to the same conditions.

        :param grantee: the principal being granted permission.
        :param constructs: The list of constructs that will have the generated resource tag applied to them.
        :param tag_key_suffix: A suffix to use on the generated Tag key in place of the generated hash value. Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)
        '''
        ...


class _IVolumeProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''An EBS Volume in AWS EC2.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVolume"

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The availability zone that the EBS Volume is contained within (ex: us-west-2a).'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="volumeId")
    def volume_id(self) -> builtins.str:
        '''The EBS Volume's ID.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "volumeId"))

    @builtins.property
    @jsii.member(jsii_name="encryptionKey")
    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The customer-managed encryption key that is used to encrypt the Volume.

        :attribute: true
        '''
        return typing.cast(typing.Optional[_IKey_5f11635f], jsii.get(self, "encryptionKey"))

    @jsii.member(jsii_name="grantAttachVolume")
    def grant_attach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach this Volume to an instance.

        CAUTION: Granting an instance permission to attach to itself using this method will lead to
        an unresolvable circular reference between the instance role and the instance.
        Use ``IVolume.grantAttachVolumeToSelf`` to grant an instance permission to attach this
        volume to itself.

        :param grantee: the principal being granted permission.
        :param instances: the instances to which permission is being granted to attach this volume to. If not specified, then permission is granted to attach to all instances in this account.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c1a65c8e09d2dd3f490d9ea3759672d994218e8ff9860d503c281ed504be84b)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument instances", value=instances, expected_type=type_hints["instances"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantAttachVolume", [grantee, instances]))

    @jsii.member(jsii_name="grantAttachVolumeByResourceTag")
    def grant_attach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach the Volume by a ResourceTag condition.

        If you are looking to
        grant an Instance, AutoScalingGroup, EC2-Fleet, SpotFleet, ECS host, etc the ability to attach
        this volume to **itself** then this is the method you want to use.

        This is implemented by adding a Tag with key ``VolumeGrantAttach-<suffix>`` to the given
        constructs and this Volume, and then conditioning the Grant such that the grantee is only
        given the ability to AttachVolume if both the Volume and the destination Instance have that
        tag applied to them.

        :param grantee: the principal being granted permission.
        :param constructs: The list of constructs that will have the generated resource tag applied to them.
        :param tag_key_suffix: A suffix to use on the generated Tag key in place of the generated hash value. Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71d799af033c60cb531ed9dd09282b1f9abcd2d8b58a8565aae5ba1bb90cf16a)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument constructs", value=constructs, expected_type=type_hints["constructs"])
            check_type(argname="argument tag_key_suffix", value=tag_key_suffix, expected_type=type_hints["tag_key_suffix"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantAttachVolumeByResourceTag", [grantee, constructs, tag_key_suffix]))

    @jsii.member(jsii_name="grantDetachVolume")
    def grant_detach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach this Volume from an instance CAUTION: Granting an instance permission to detach from itself using this method will lead to an unresolvable circular reference between the instance role and the instance.

        Use ``IVolume.grantDetachVolumeFromSelf`` to grant an instance permission to detach this
        volume from itself.

        :param grantee: the principal being granted permission.
        :param instances: the instances to which permission is being granted to detach this volume from. If not specified, then permission is granted to detach from all instances in this account.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdec016a71973f32a7e119ad64acbdbaeec9f6c277881f45f4b57c30b8c8a29a)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument instances", value=instances, expected_type=type_hints["instances"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantDetachVolume", [grantee, instances]))

    @jsii.member(jsii_name="grantDetachVolumeByResourceTag")
    def grant_detach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach the Volume by a ResourceTag condition.

        This is implemented via the same mechanism as ``IVolume.grantAttachVolumeByResourceTag``,
        and is subject to the same conditions.

        :param grantee: the principal being granted permission.
        :param constructs: The list of constructs that will have the generated resource tag applied to them.
        :param tag_key_suffix: A suffix to use on the generated Tag key in place of the generated hash value. Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9572d33fd8dab37c25d4e29559ce658af3b0cbefb47b37ae545cd2e9dac34247)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument constructs", value=constructs, expected_type=type_hints["constructs"])
            check_type(argname="argument tag_key_suffix", value=tag_key_suffix, expected_type=type_hints["tag_key_suffix"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantDetachVolumeByResourceTag", [grantee, constructs, tag_key_suffix]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVolume).__jsii_proxy_class__ = lambda : _IVolumeProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpc")
class IVpc(_IResource_c80c4260, typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="availabilityZones")
    def availability_zones(self) -> typing.List[builtins.str]:
        '''AZs for this VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force internet connectivity established on the VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="isolatedSubnets")
    def isolated_subnets(self) -> typing.List[ISubnet]:
        '''List of isolated subnets in this VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="privateSubnets")
    def private_subnets(self) -> typing.List[ISubnet]:
        '''List of private subnets in this VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="publicSubnets")
    def public_subnets(self) -> typing.List[ISubnet]:
        '''List of public subnets in this VPC.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpcArn")
    def vpc_arn(self) -> builtins.str:
        '''ARN for this VPC.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpcCidrBlock")
    def vpc_cidr_block(self) -> builtins.str:
        '''CIDR range for this VPC.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''Identifier for this VPC.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''Identifier for the VPN gateway.'''
        ...

    @jsii.member(jsii_name="addClientVpnEndpoint")
    def add_client_vpn_endpoint(
        self,
        id: builtins.str,
        *,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional["VpnPort"] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional["TransportProtocol"] = None,
        user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "ClientVpnEndpoint":
        '''Adds a new client VPN endpoint to this VPC.

        :param id: -
        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy
        '''
        ...

    @jsii.member(jsii_name="addFlowLog")
    def add_flow_log(
        self,
        id: builtins.str,
        *,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence["LogFormat"]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional[FlowLogTrafficType] = None,
    ) -> "FlowLog":
        '''Adds a new Flow Log to this VPC.

        :param id: -
        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL
        '''
        ...

    @jsii.member(jsii_name="addGatewayEndpoint")
    def add_gateway_endpoint(
        self,
        id: builtins.str,
        *,
        service: IGatewayVpcEndpointService,
        subnets: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "GatewayVpcEndpoint":
        '''Adds a new gateway endpoint to this VPC.

        :param id: -
        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC
        '''
        ...

    @jsii.member(jsii_name="addInterfaceEndpoint")
    def add_interface_endpoint(
        self,
        id: builtins.str,
        *,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "InterfaceVpcEndpoint":
        '''Adds a new interface endpoint to this VPC.

        :param id: -
        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets
        '''
        ...

    @jsii.member(jsii_name="addVpnConnection")
    def add_vpn_connection(
        self,
        id: builtins.str,
        *,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union["VpnTunnelOption", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "VpnConnection":
        '''Adds a new VPN connection to this VPC.

        :param id: -
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options
        '''
        ...

    @jsii.member(jsii_name="enableVpnGateway")
    def enable_vpn_gateway(
        self,
        *,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Adds a VPN Gateway to this VPC.

        :param vpn_route_propagation: Provide an array of subnets where the route propagation should be added. Default: noPropagation
        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000
        '''
        ...

    @jsii.member(jsii_name="selectSubnets")
    def select_subnets(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence["SubnetFilter"]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional["SubnetType"] = None,
    ) -> "SelectedSubnets":
        '''Return information on the subnets appropriate for the given selection strategy.

        Requires that at least one subnet is matched, throws a descriptive
        error message otherwise.

        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        ...


class _IVpcProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpc"

    @builtins.property
    @jsii.member(jsii_name="availabilityZones")
    def availability_zones(self) -> typing.List[builtins.str]:
        '''AZs for this VPC.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "availabilityZones"))

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force internet connectivity established on the VPC.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "internetConnectivityEstablished"))

    @builtins.property
    @jsii.member(jsii_name="isolatedSubnets")
    def isolated_subnets(self) -> typing.List[ISubnet]:
        '''List of isolated subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "isolatedSubnets"))

    @builtins.property
    @jsii.member(jsii_name="privateSubnets")
    def private_subnets(self) -> typing.List[ISubnet]:
        '''List of private subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "privateSubnets"))

    @builtins.property
    @jsii.member(jsii_name="publicSubnets")
    def public_subnets(self) -> typing.List[ISubnet]:
        '''List of public subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "publicSubnets"))

    @builtins.property
    @jsii.member(jsii_name="vpcArn")
    def vpc_arn(self) -> builtins.str:
        '''ARN for this VPC.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcArn"))

    @builtins.property
    @jsii.member(jsii_name="vpcCidrBlock")
    def vpc_cidr_block(self) -> builtins.str:
        '''CIDR range for this VPC.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcCidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''Identifier for this VPC.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''Identifier for the VPN gateway.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpnGatewayId"))

    @jsii.member(jsii_name="addClientVpnEndpoint")
    def add_client_vpn_endpoint(
        self,
        id: builtins.str,
        *,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional["VpnPort"] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional["TransportProtocol"] = None,
        user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "ClientVpnEndpoint":
        '''Adds a new client VPN endpoint to this VPC.

        :param id: -
        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__19cdaa7bec0f733a863944b2be6c76392b1e518714158a913370b8de7c09e2e0)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = ClientVpnEndpointOptions(
            cidr=cidr,
            server_certificate_arn=server_certificate_arn,
            authorize_all_users_to_vpc_cidr=authorize_all_users_to_vpc_cidr,
            client_certificate_arn=client_certificate_arn,
            client_connection_handler=client_connection_handler,
            client_login_banner=client_login_banner,
            description=description,
            dns_servers=dns_servers,
            logging=logging,
            log_group=log_group,
            log_stream=log_stream,
            port=port,
            security_groups=security_groups,
            self_service_portal=self_service_portal,
            session_timeout=session_timeout,
            split_tunnel=split_tunnel,
            transport_protocol=transport_protocol,
            user_based_authentication=user_based_authentication,
            vpc_subnets=vpc_subnets,
        )

        return typing.cast("ClientVpnEndpoint", jsii.invoke(self, "addClientVpnEndpoint", [id, options]))

    @jsii.member(jsii_name="addFlowLog")
    def add_flow_log(
        self,
        id: builtins.str,
        *,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence["LogFormat"]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional[FlowLogTrafficType] = None,
    ) -> "FlowLog":
        '''Adds a new Flow Log to this VPC.

        :param id: -
        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0135e094843a52d426b6a129842d492990380d64cab0d48db48f4dbe0d9e575b)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = FlowLogOptions(
            destination=destination,
            log_format=log_format,
            max_aggregation_interval=max_aggregation_interval,
            traffic_type=traffic_type,
        )

        return typing.cast("FlowLog", jsii.invoke(self, "addFlowLog", [id, options]))

    @jsii.member(jsii_name="addGatewayEndpoint")
    def add_gateway_endpoint(
        self,
        id: builtins.str,
        *,
        service: IGatewayVpcEndpointService,
        subnets: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "GatewayVpcEndpoint":
        '''Adds a new gateway endpoint to this VPC.

        :param id: -
        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__23a57d5868b6e331624362856f06299729cc32be285aa37cc5efbef529bf3054)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = GatewayVpcEndpointOptions(service=service, subnets=subnets)

        return typing.cast("GatewayVpcEndpoint", jsii.invoke(self, "addGatewayEndpoint", [id, options]))

    @jsii.member(jsii_name="addInterfaceEndpoint")
    def add_interface_endpoint(
        self,
        id: builtins.str,
        *,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "InterfaceVpcEndpoint":
        '''Adds a new interface endpoint to this VPC.

        :param id: -
        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a8399f0a6a7650e1c02d00770e21cad422b9760a1fdc24465cf54637106df2ac)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = InterfaceVpcEndpointOptions(
            service=service,
            lookup_supported_azs=lookup_supported_azs,
            open=open,
            private_dns_enabled=private_dns_enabled,
            security_groups=security_groups,
            subnets=subnets,
        )

        return typing.cast("InterfaceVpcEndpoint", jsii.invoke(self, "addInterfaceEndpoint", [id, options]))

    @jsii.member(jsii_name="addVpnConnection")
    def add_vpn_connection(
        self,
        id: builtins.str,
        *,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union["VpnTunnelOption", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "VpnConnection":
        '''Adds a new VPN connection to this VPC.

        :param id: -
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b660f36091ef3f17b29e55486b85b99103af4b45b1c0c12b38092a051a0b7782)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = VpnConnectionOptions(
            ip=ip, asn=asn, static_routes=static_routes, tunnel_options=tunnel_options
        )

        return typing.cast("VpnConnection", jsii.invoke(self, "addVpnConnection", [id, options]))

    @jsii.member(jsii_name="enableVpnGateway")
    def enable_vpn_gateway(
        self,
        *,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]]] = None,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Adds a VPN Gateway to this VPC.

        :param vpn_route_propagation: Provide an array of subnets where the route propagation should be added. Default: noPropagation
        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000
        '''
        options = EnableVpnGatewayOptions(
            vpn_route_propagation=vpn_route_propagation,
            type=type,
            amazon_side_asn=amazon_side_asn,
        )

        return typing.cast(None, jsii.invoke(self, "enableVpnGateway", [options]))

    @jsii.member(jsii_name="selectSubnets")
    def select_subnets(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence["SubnetFilter"]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional["SubnetType"] = None,
    ) -> "SelectedSubnets":
        '''Return information on the subnets appropriate for the given selection strategy.

        Requires that at least one subnet is matched, throws a descriptive
        error message otherwise.

        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        selection = SubnetSelection(
            availability_zones=availability_zones,
            one_per_az=one_per_az,
            subnet_filters=subnet_filters,
            subnet_group_name=subnet_group_name,
            subnets=subnets,
            subnet_type=subnet_type,
        )

        return typing.cast("SelectedSubnets", jsii.invoke(self, "selectSubnets", [selection]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpc).__jsii_proxy_class__ = lambda : _IVpcProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpcEndpoint")
class IVpcEndpoint(_IResource_c80c4260, typing_extensions.Protocol):
    '''A VPC endpoint.'''

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> builtins.str:
        '''The VPC endpoint identifier.

        :attribute: true
        '''
        ...


class _IVpcEndpointProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A VPC endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpcEndpoint"

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> builtins.str:
        '''The VPC endpoint identifier.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpcEndpoint).__jsii_proxy_class__ = lambda : _IVpcEndpointProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpcEndpointService")
class IVpcEndpointService(_IResource_c80c4260, typing_extensions.Protocol):
    '''A VPC endpoint service.'''

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceId")
    def vpc_endpoint_service_id(self) -> builtins.str:
        '''The id of the VPC Endpoint Service that clients use to connect to, like vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> builtins.str:
        '''The service name of the VPC Endpoint Service that clients use to connect to, like com.amazonaws.vpce..vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        ...


class _IVpcEndpointServiceProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''A VPC endpoint service.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpcEndpointService"

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceId")
    def vpc_endpoint_service_id(self) -> builtins.str:
        '''The id of the VPC Endpoint Service that clients use to connect to, like vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointServiceId"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> builtins.str:
        '''The service name of the VPC Endpoint Service that clients use to connect to, like com.amazonaws.vpce..vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointServiceName"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpcEndpointService).__jsii_proxy_class__ = lambda : _IVpcEndpointServiceProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpcEndpointServiceLoadBalancer")
class IVpcEndpointServiceLoadBalancer(typing_extensions.Protocol):
    '''A load balancer that can host a VPC Endpoint Service.'''

    @builtins.property
    @jsii.member(jsii_name="loadBalancerArn")
    def load_balancer_arn(self) -> builtins.str:
        '''The ARN of the load balancer that hosts the VPC Endpoint Service.

        :attribute: true
        '''
        ...


class _IVpcEndpointServiceLoadBalancerProxy:
    '''A load balancer that can host a VPC Endpoint Service.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpcEndpointServiceLoadBalancer"

    @builtins.property
    @jsii.member(jsii_name="loadBalancerArn")
    def load_balancer_arn(self) -> builtins.str:
        '''The ARN of the load balancer that hosts the VPC Endpoint Service.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "loadBalancerArn"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpcEndpointServiceLoadBalancer).__jsii_proxy_class__ = lambda : _IVpcEndpointServiceLoadBalancerProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpnConnection")
class IVpnConnection(_IResource_c80c4260, typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="customerGatewayAsn")
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="customerGatewayIp")
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpnId")
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.

        :attribute: VpnConnectionId
        '''
        ...

    @jsii.member(jsii_name="metric")
    def metric(
        self,
        metric_name: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Return the given named metric for this VPNConnection.

        :param metric_name: -
        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        ...

    @jsii.member(jsii_name="metricTunnelDataIn")
    def metric_tunnel_data_in(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes received through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        ...

    @jsii.member(jsii_name="metricTunnelDataOut")
    def metric_tunnel_data_out(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes sent through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        ...

    @jsii.member(jsii_name="metricTunnelState")
    def metric_tunnel_state(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The state of the tunnel. 0 indicates DOWN and 1 indicates UP.

        Average over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        ...


class _IVpnConnectionProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpnConnection"

    @builtins.property
    @jsii.member(jsii_name="customerGatewayAsn")
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        return typing.cast(jsii.Number, jsii.get(self, "customerGatewayAsn"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayIp")
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayIp"))

    @builtins.property
    @jsii.member(jsii_name="vpnId")
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.

        :attribute: VpnConnectionId
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpnId"))

    @jsii.member(jsii_name="metric")
    def metric(
        self,
        metric_name: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Return the given named metric for this VPNConnection.

        :param metric_name: -
        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a2c1c58afbc5e81e1af61d18f3f4b2f840465db1e0e780c358e83b3a110de5ad)
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metric", [metric_name, props]))

    @jsii.member(jsii_name="metricTunnelDataIn")
    def metric_tunnel_data_in(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes received through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelDataIn", [props]))

    @jsii.member(jsii_name="metricTunnelDataOut")
    def metric_tunnel_data_out(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes sent through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelDataOut", [props]))

    @jsii.member(jsii_name="metricTunnelState")
    def metric_tunnel_state(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The state of the tunnel. 0 indicates DOWN and 1 indicates UP.

        Average over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelState", [props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpnConnection).__jsii_proxy_class__ = lambda : _IVpnConnectionProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IVpnGateway")
class IVpnGateway(_IResource_c80c4260, typing_extensions.Protocol):
    '''The virtual private gateway interface.'''

    @builtins.property
    @jsii.member(jsii_name="gatewayId")
    def gateway_id(self) -> builtins.str:
        '''The virtual private gateway Id.'''
        ...


class _IVpnGatewayProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
):
    '''The virtual private gateway interface.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IVpnGateway"

    @builtins.property
    @jsii.member(jsii_name="gatewayId")
    def gateway_id(self) -> builtins.str:
        '''The virtual private gateway Id.'''
        return typing.cast(builtins.str, jsii.get(self, "gatewayId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IVpnGateway).__jsii_proxy_class__ = lambda : _IVpnGatewayProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitCommandOptions",
    jsii_struct_bases=[],
    name_mapping={
        "cwd": "cwd",
        "env": "env",
        "ignore_errors": "ignoreErrors",
        "key": "key",
        "service_restart_handles": "serviceRestartHandles",
        "test_cmd": "testCmd",
        "wait_after_completion": "waitAfterCompletion",
    },
)
class InitCommandOptions:
    def __init__(
        self,
        *,
        cwd: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        ignore_errors: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        test_cmd: typing.Optional[builtins.str] = None,
        wait_after_completion: typing.Optional["InitCommandWaitDuration"] = None,
    ) -> None:
        '''Options for InitCommand.

        :param cwd: The working directory. Default: - Use default working directory
        :param env: Sets environment variables for the command. This property overwrites, rather than appends, the existing environment. Default: - Use current environment
        :param ignore_errors: Continue running if this command fails. Default: false
        :param key: Identifier key for this command. Commands are executed in lexicographical order of their key names. Default: - Automatically generated based on index
        :param service_restart_handles: Restart the given service(s) after this command has run. Default: - Do not restart any service
        :param test_cmd: Command to determine whether this command should be run. If the test passes (exits with error code of 0), the command is run. Default: - Always run the command
        :param wait_after_completion: The duration to wait after a command has finished in case the command causes a reboot. Set this value to ``InitCommandWaitDuration.none()`` if you do not want to wait for every command; ``InitCommandWaitDuration.forever()`` directs cfn-init to exit and resume only after the reboot is complete. For Windows systems only. Default: - 60 seconds

        :exampleMetadata: infused

        Example::

            handle = ec2.InitServiceRestartHandle()
            ec2.CloudFormationInit.from_elements(
                ec2.InitCommand.shell_command("/usr/bin/custom-nginx-install.sh", service_restart_handles=[handle]),
                ec2.InitService.enable("nginx", service_restart_handle=handle))
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__895498aa03e26d375242198136c0bb6545f960467ad94c90bc9418b7522a7bfc)
            check_type(argname="argument cwd", value=cwd, expected_type=type_hints["cwd"])
            check_type(argname="argument env", value=env, expected_type=type_hints["env"])
            check_type(argname="argument ignore_errors", value=ignore_errors, expected_type=type_hints["ignore_errors"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
            check_type(argname="argument test_cmd", value=test_cmd, expected_type=type_hints["test_cmd"])
            check_type(argname="argument wait_after_completion", value=wait_after_completion, expected_type=type_hints["wait_after_completion"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cwd is not None:
            self._values["cwd"] = cwd
        if env is not None:
            self._values["env"] = env
        if ignore_errors is not None:
            self._values["ignore_errors"] = ignore_errors
        if key is not None:
            self._values["key"] = key
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles
        if test_cmd is not None:
            self._values["test_cmd"] = test_cmd
        if wait_after_completion is not None:
            self._values["wait_after_completion"] = wait_after_completion

    @builtins.property
    def cwd(self) -> typing.Optional[builtins.str]:
        '''The working directory.

        :default: - Use default working directory
        '''
        result = self._values.get("cwd")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def env(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''Sets environment variables for the command.

        This property overwrites, rather than appends, the existing environment.

        :default: - Use current environment
        '''
        result = self._values.get("env")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def ignore_errors(self) -> typing.Optional[builtins.bool]:
        '''Continue running if this command fails.

        :default: false
        '''
        result = self._values.get("ignore_errors")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''Identifier key for this command.

        Commands are executed in lexicographical order of their key names.

        :default: - Automatically generated based on index
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List["InitServiceRestartHandle"]]:
        '''Restart the given service(s) after this command has run.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List["InitServiceRestartHandle"]], result)

    @builtins.property
    def test_cmd(self) -> typing.Optional[builtins.str]:
        '''Command to determine whether this command should be run.

        If the test passes (exits with error code of 0), the command is run.

        :default: - Always run the command
        '''
        result = self._values.get("test_cmd")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def wait_after_completion(self) -> typing.Optional["InitCommandWaitDuration"]:
        '''The duration to wait after a command has finished in case the command causes a reboot.

        Set this value to ``InitCommandWaitDuration.none()`` if you do not want to wait for every command;
        ``InitCommandWaitDuration.forever()`` directs cfn-init to exit and resume only after the reboot is complete.

        For Windows systems only.

        :default: - 60 seconds
        '''
        result = self._values.get("wait_after_completion")
        return typing.cast(typing.Optional["InitCommandWaitDuration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitCommandOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class InitCommandWaitDuration(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.InitCommandWaitDuration",
):
    '''Represents a duration to wait after a command has finished, in case of a reboot (Windows only).

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        init_command_wait_duration = ec2.InitCommandWaitDuration.forever()
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="forever")
    @builtins.classmethod
    def forever(cls) -> "InitCommandWaitDuration":
        '''cfn-init will exit and resume only after a reboot.'''
        return typing.cast("InitCommandWaitDuration", jsii.sinvoke(cls, "forever", []))

    @jsii.member(jsii_name="none")
    @builtins.classmethod
    def none(cls) -> "InitCommandWaitDuration":
        '''Do not wait for this command.'''
        return typing.cast("InitCommandWaitDuration", jsii.sinvoke(cls, "none", []))

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(cls, duration: _Duration_4839e8c3) -> "InitCommandWaitDuration":
        '''Wait for a specified duration after a command.

        :param duration: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aa7b7f77fc9110826ec8df74528870f896a286b3793b09bec1879840a13d8200)
            check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
        return typing.cast("InitCommandWaitDuration", jsii.sinvoke(cls, "of", [duration]))


class _InitCommandWaitDurationProxy(InitCommandWaitDuration):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, InitCommandWaitDuration).__jsii_proxy_class__ = lambda : _InitCommandWaitDurationProxy


class InitConfig(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.InitConfig"):
    '''A collection of configuration elements.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        # machine_image: ec2.IMachineImage
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=machine_image,
        
            # Showing the most complex setup, if you have simpler requirements
            # you can use `CloudFormationInit.fromElements()`.
            init=ec2.CloudFormationInit.from_config_sets(
                config_sets={
                    # Applies the configs below in this order
                    "default": ["yumPreinstall", "config"]
                },
                configs={
                    "yum_preinstall": ec2.InitConfig([
                        # Install an Amazon Linux package using yum
                        ec2.InitPackage.yum("git")
                    ]),
                    "config": ec2.InitConfig([
                        # Create a JSON file from tokens (can also create other files)
                        ec2.InitFile.from_object("/etc/stack.json", {
                            "stack_id": Stack.of(self).stack_id,
                            "stack_name": Stack.of(self).stack_name,
                            "region": Stack.of(self).region
                        }),
        
                        # Create a group and user
                        ec2.InitGroup.from_name("my-group"),
                        ec2.InitUser.from_name("my-user"),
        
                        # Install an RPM from the internet
                        ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                    ])
                }
            ),
            init_options=ec2.ApplyCloudFormationInitOptions(
                # Optional, which configsets to activate (['default'] by default)
                config_sets=["default"],
        
                # Optional, how long the installation is expected to take (5 minutes by default)
                timeout=Duration.minutes(30),
        
                # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                include_url=True,
        
                # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                include_role=True
            )
        )
    '''

    def __init__(self, elements: typing.Sequence["InitElement"]) -> None:
        '''
        :param elements: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f2fe8a9cd0b26d1fa0c137055d0db7f12f14f6ee9a3617696e66b4a4db761be8)
            check_type(argname="argument elements", value=elements, expected_type=type_hints["elements"])
        jsii.create(self.__class__, self, [elements])

    @jsii.member(jsii_name="add")
    def add(self, *elements: "InitElement") -> None:
        '''Add one or more elements to the config.

        :param elements: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__237bb2e0a082e15538325c591128f1099768227eae00078b5ae7f19d9dc5c438)
            check_type(argname="argument elements", value=elements, expected_type=typing.Tuple[type_hints["elements"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "add", [*elements]))

    @jsii.member(jsii_name="isEmpty")
    def is_empty(self) -> builtins.bool:
        '''Whether this configset has elements or not.'''
        return typing.cast(builtins.bool, jsii.invoke(self, "isEmpty", []))


class InitElement(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.InitElement",
):
    '''Base class for all CloudFormation Init elements.

    :exampleMetadata: infused

    Example::

        # my_bucket: s3.Bucket
        
        
        handle = ec2.InitServiceRestartHandle()
        
        ec2.CloudFormationInit.from_elements(
            ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
            ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
            ec2.InitService.enable("nginx",
                service_restart_handle=handle
            ))
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @builtins.property
    @jsii.member(jsii_name="elementType")
    @abc.abstractmethod
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        ...


class _InitElementProxy(InitElement):
    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, InitElement).__jsii_proxy_class__ = lambda : _InitElementProxy


class InitFile(
    InitElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.InitFile",
):
    '''Create files on the EC2 instance.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
        
            init=ec2.CloudFormationInit.from_elements(
                # Create a simple config file that runs a Python web server
                ec2.InitService.systemd_config_file("simpleserver",
                    command="/usr/bin/python3 -m http.server 8080",
                    cwd="/var/www/html"
                ),
                # Start the server using SystemD
                ec2.InitService.enable("simpleserver",
                    service_manager=ec2.ServiceManager.SYSTEMD
                ),
                # Drop an example file to show the web server working
                ec2.InitFile.from_string("/var/www/html/index.html", "Hello! It's working!"))
        )
    '''

    def __init__(
        self,
        file_name: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> None:
        '''
        :param file_name: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39a56bb260f932761d77b0140dc161ded874ce9256c33b195c00a72633e7613a)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        jsii.create(self.__class__, self, [file_name, options])

    @jsii.member(jsii_name="fromAsset")
    @builtins.classmethod
    def from_asset(
        cls,
        target_file_name: builtins.str,
        path: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        deploy_time: typing.Optional[builtins.bool] = None,
        readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
        asset_hash: typing.Optional[builtins.str] = None,
        asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
        bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
        follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
        ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
    ) -> "InitFile":
        '''Create an asset from the given file.

        This is appropriate for files that are too large to embed into the template.

        :param target_file_name: -
        :param path: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
        :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.
        :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
        :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
        :param exclude: File paths matching the patterns will be excluded. See ``ignoreMode`` to set the matching behavior. Has no effect on Assets bundled using the ``bundling`` property. Default: - nothing is excluded
        :param follow_symlinks: A strategy for how to handle symlinks. Default: SymlinkFollowMode.NEVER
        :param ignore_mode: The ignore behavior to use for ``exclude`` patterns. Default: IgnoreMode.GLOB
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__164f7ae4723652c2e5c3189a870d0dbd16f8bec14d0e807d648248a60dff8f47)
            check_type(argname="argument target_file_name", value=target_file_name, expected_type=type_hints["target_file_name"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        options = InitFileAssetOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
            deploy_time=deploy_time,
            readers=readers,
            asset_hash=asset_hash,
            asset_hash_type=asset_hash_type,
            bundling=bundling,
            exclude=exclude,
            follow_symlinks=follow_symlinks,
            ignore_mode=ignore_mode,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromAsset", [target_file_name, path, options]))

    @jsii.member(jsii_name="fromExistingAsset")
    @builtins.classmethod
    def from_existing_asset(
        cls,
        target_file_name: builtins.str,
        asset: _Asset_ac2a7e61,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Use a file from an asset at instance startup time.

        :param target_file_name: -
        :param asset: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b888ad30ba14ff553b01013ce3c63033fc6ba7c5e38ed591fa853b73bcfd6f7c)
            check_type(argname="argument target_file_name", value=target_file_name, expected_type=type_hints["target_file_name"])
            check_type(argname="argument asset", value=asset, expected_type=type_hints["asset"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromExistingAsset", [target_file_name, asset, options]))

    @jsii.member(jsii_name="fromFileInline")
    @builtins.classmethod
    def from_file_inline(
        cls,
        target_file_name: builtins.str,
        source_file_name: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Read a file from disk and use its contents.

        The file will be embedded in the template, so care should be taken to not
        exceed the template size.

        If options.base64encoded is set to true, this will base64-encode the file's contents.

        :param target_file_name: -
        :param source_file_name: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a7470c7a0aaf62b8c70ecc66688ff44ffba8d8346bf7ba2d28ce1fc200ca0219)
            check_type(argname="argument target_file_name", value=target_file_name, expected_type=type_hints["target_file_name"])
            check_type(argname="argument source_file_name", value=source_file_name, expected_type=type_hints["source_file_name"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromFileInline", [target_file_name, source_file_name, options]))

    @jsii.member(jsii_name="fromObject")
    @builtins.classmethod
    def from_object(
        cls,
        file_name: builtins.str,
        obj: typing.Mapping[builtins.str, typing.Any],
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Use a JSON-compatible object as the file content, write it to a JSON file.

        May contain tokens.

        :param file_name: -
        :param obj: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f988faf01115ca4996c275b3845c5944782257ad279b916362511c00db7af01d)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
            check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromObject", [file_name, obj, options]))

    @jsii.member(jsii_name="fromS3Object")
    @builtins.classmethod
    def from_s3_object(
        cls,
        file_name: builtins.str,
        bucket: _IBucket_42e086fd,
        key: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Download a file from an S3 bucket at instance startup time.

        :param file_name: -
        :param bucket: -
        :param key: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__331a134b436a492e3e40262ea88ee560c7a93d024631502fcff730bd2e24001a)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromS3Object", [file_name, bucket, key, options]))

    @jsii.member(jsii_name="fromString")
    @builtins.classmethod
    def from_string(
        cls,
        file_name: builtins.str,
        content: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Use a literal string as the file content.

        :param file_name: -
        :param content: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd20249bee2a42e1c6df6cd6c7ff87611924246dd9ceb3b13fa55b42744249c6)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
            check_type(argname="argument content", value=content, expected_type=type_hints["content"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromString", [file_name, content, options]))

    @jsii.member(jsii_name="fromUrl")
    @builtins.classmethod
    def from_url(
        cls,
        file_name: builtins.str,
        url: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Download from a URL at instance startup time.

        :param file_name: -
        :param url: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1ae14eda61de45cd6b65d6dcd8e43beff37720eecc1008e5b0da1864c366857)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
            check_type(argname="argument url", value=url, expected_type=type_hints["url"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "fromUrl", [file_name, url, options]))

    @jsii.member(jsii_name="symlink")
    @builtins.classmethod
    def symlink(
        cls,
        file_name: builtins.str,
        target: builtins.str,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitFile":
        '''Write a symlink with the given symlink target.

        :param file_name: -
        :param target: -
        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__33ac8fc20cb2d02dff9d497b10d5e0199a84409d271fc870831888220a16a472)
            check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
        options = InitFileOptions(
            base64_encoded=base64_encoded,
            group=group,
            mode=mode,
            owner=owner,
            service_restart_handles=service_restart_handles,
        )

        return typing.cast("InitFile", jsii.sinvoke(cls, "symlink", [file_name, target, options]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


class _InitFileProxy(
    InitFile,
    jsii.proxy_for(InitElement), # type: ignore[misc]
):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, InitFile).__jsii_proxy_class__ = lambda : _InitFileProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitFileOptions",
    jsii_struct_bases=[],
    name_mapping={
        "base64_encoded": "base64Encoded",
        "group": "group",
        "mode": "mode",
        "owner": "owner",
        "service_restart_handles": "serviceRestartHandles",
    },
)
class InitFileOptions:
    def __init__(
        self,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> None:
        '''Options for InitFile.

        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service

        :exampleMetadata: infused

        Example::

            # my_bucket: s3.Bucket
            
            
            handle = ec2.InitServiceRestartHandle()
            
            ec2.CloudFormationInit.from_elements(
                ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
                ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
                ec2.InitService.enable("nginx",
                    service_restart_handle=handle
                ))
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9327bb8cfe7f6b516e904c6a9d60ffd97b10398f99361ba1f6b1b72c5b274c60)
            check_type(argname="argument base64_encoded", value=base64_encoded, expected_type=type_hints["base64_encoded"])
            check_type(argname="argument group", value=group, expected_type=type_hints["group"])
            check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
            check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if base64_encoded is not None:
            self._values["base64_encoded"] = base64_encoded
        if group is not None:
            self._values["group"] = group
        if mode is not None:
            self._values["mode"] = mode
        if owner is not None:
            self._values["owner"] = owner
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles

    @builtins.property
    def base64_encoded(self) -> typing.Optional[builtins.bool]:
        '''True if the inlined content (from a string or file) should be treated as base64 encoded.

        Only applicable for inlined string and file content.

        :default: false
        '''
        result = self._values.get("base64_encoded")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def group(self) -> typing.Optional[builtins.str]:
        '''The name of the owning group for this file.

        Not supported for Windows systems.

        :default: 'root'
        '''
        result = self._values.get("group")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def mode(self) -> typing.Optional[builtins.str]:
        '''A six-digit octal value representing the mode for this file.

        Use the first three digits for symlinks and the last three digits for
        setting permissions. To create a symlink, specify 120xxx, where xxx
        defines the permissions of the target file. To specify permissions for a
        file, use the last three digits, such as 000644.

        Not supported for Windows systems.

        :default: '000644'
        '''
        result = self._values.get("mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def owner(self) -> typing.Optional[builtins.str]:
        '''The name of the owning user for this file.

        Not supported for Windows systems.

        :default: 'root'
        '''
        result = self._values.get("owner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List["InitServiceRestartHandle"]]:
        '''Restart the given service after this file has been written.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List["InitServiceRestartHandle"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitFileOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class InitGroup(
    InitElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitGroup",
):
    '''Create Linux/UNIX groups and assign group IDs.

    Not supported for Windows systems.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        # machine_image: ec2.IMachineImage
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=machine_image,
        
            # Showing the most complex setup, if you have simpler requirements
            # you can use `CloudFormationInit.fromElements()`.
            init=ec2.CloudFormationInit.from_config_sets(
                config_sets={
                    # Applies the configs below in this order
                    "default": ["yumPreinstall", "config"]
                },
                configs={
                    "yum_preinstall": ec2.InitConfig([
                        # Install an Amazon Linux package using yum
                        ec2.InitPackage.yum("git")
                    ]),
                    "config": ec2.InitConfig([
                        # Create a JSON file from tokens (can also create other files)
                        ec2.InitFile.from_object("/etc/stack.json", {
                            "stack_id": Stack.of(self).stack_id,
                            "stack_name": Stack.of(self).stack_name,
                            "region": Stack.of(self).region
                        }),
        
                        # Create a group and user
                        ec2.InitGroup.from_name("my-group"),
                        ec2.InitUser.from_name("my-user"),
        
                        # Install an RPM from the internet
                        ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                    ])
                }
            ),
            init_options=ec2.ApplyCloudFormationInitOptions(
                # Optional, which configsets to activate (['default'] by default)
                config_sets=["default"],
        
                # Optional, how long the installation is expected to take (5 minutes by default)
                timeout=Duration.minutes(30),
        
                # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                include_url=True,
        
                # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                include_role=True
            )
        )
    '''

    def __init__(
        self,
        group_name: builtins.str,
        group_id: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param group_name: -
        :param group_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e55da79543d30150ac899cf419393b414293eb4ccadf4e7cfcd02bc3a6ff53f)
            check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
        jsii.create(self.__class__, self, [group_name, group_id])

    @jsii.member(jsii_name="fromName")
    @builtins.classmethod
    def from_name(
        cls,
        group_name: builtins.str,
        group_id: typing.Optional[jsii.Number] = None,
    ) -> "InitGroup":
        '''Create a group from its name, and optionally, group id.

        :param group_name: -
        :param group_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__038b5306a766a3f74d8ec7c0d18d563af893a3de0f27baa0451cdef5fbda37df)
            check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
            check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
        return typing.cast("InitGroup", jsii.sinvoke(cls, "fromName", [group_name, group_id]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


class InitPackage(
    InitElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitPackage",
):
    '''A package to be installed during cfn-init time.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        # machine_image: ec2.IMachineImage
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=machine_image,
        
            # Showing the most complex setup, if you have simpler requirements
            # you can use `CloudFormationInit.fromElements()`.
            init=ec2.CloudFormationInit.from_config_sets(
                config_sets={
                    # Applies the configs below in this order
                    "default": ["yumPreinstall", "config"]
                },
                configs={
                    "yum_preinstall": ec2.InitConfig([
                        # Install an Amazon Linux package using yum
                        ec2.InitPackage.yum("git")
                    ]),
                    "config": ec2.InitConfig([
                        # Create a JSON file from tokens (can also create other files)
                        ec2.InitFile.from_object("/etc/stack.json", {
                            "stack_id": Stack.of(self).stack_id,
                            "stack_name": Stack.of(self).stack_name,
                            "region": Stack.of(self).region
                        }),
        
                        # Create a group and user
                        ec2.InitGroup.from_name("my-group"),
                        ec2.InitUser.from_name("my-user"),
        
                        # Install an RPM from the internet
                        ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                    ])
                }
            ),
            init_options=ec2.ApplyCloudFormationInitOptions(
                # Optional, which configsets to activate (['default'] by default)
                config_sets=["default"],
        
                # Optional, how long the installation is expected to take (5 minutes by default)
                timeout=Duration.minutes(30),
        
                # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                include_url=True,
        
                # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                include_role=True
            )
        )
    '''

    def __init__(
        self,
        type: builtins.str,
        versions: typing.Sequence[builtins.str],
        package_name: typing.Optional[builtins.str] = None,
        service_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> None:
        '''
        :param type: -
        :param versions: -
        :param package_name: -
        :param service_handles: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed1c262b209111e032d161da94a1ff7dc7f47427f1ff40c9515754b0a8246bc6)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument versions", value=versions, expected_type=type_hints["versions"])
            check_type(argname="argument package_name", value=package_name, expected_type=type_hints["package_name"])
            check_type(argname="argument service_handles", value=service_handles, expected_type=type_hints["service_handles"])
        jsii.create(self.__class__, self, [type, versions, package_name, service_handles])

    @jsii.member(jsii_name="apt")
    @builtins.classmethod
    def apt(
        cls,
        package_name: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        version: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "InitPackage":
        '''Install a package using APT.

        :param package_name: -
        :param service_restart_handles: Restart the given services after this command has run. Default: - Do not restart any service
        :param version: Specify the versions to install. Default: - Install the latest version
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48e8f1ab69dd7c8b52f329ce44af093d23dbb9262ef90ffcbf902fc740f3312d)
            check_type(argname="argument package_name", value=package_name, expected_type=type_hints["package_name"])
        options = NamedPackageOptions(
            service_restart_handles=service_restart_handles, version=version
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "apt", [package_name, options]))

    @jsii.member(jsii_name="msi")
    @builtins.classmethod
    def msi(
        cls,
        location: builtins.str,
        *,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitPackage":
        '''Install an MSI package from an HTTP URL or a location on disk.

        :param location: -
        :param key: Identifier key for this package. You can use this to order package installs. Default: - Automatically generated
        :param service_restart_handles: Restart the given service after this command has run. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f339ea3f6248164c6e71705d6ffe8e12b4ad0dbfb8930a970293253ec79d8ff)
            check_type(argname="argument location", value=location, expected_type=type_hints["location"])
        options = LocationPackageOptions(
            key=key, service_restart_handles=service_restart_handles
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "msi", [location, options]))

    @jsii.member(jsii_name="python")
    @builtins.classmethod
    def python(
        cls,
        package_name: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        version: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "InitPackage":
        '''Install a package from PyPI.

        :param package_name: -
        :param service_restart_handles: Restart the given services after this command has run. Default: - Do not restart any service
        :param version: Specify the versions to install. Default: - Install the latest version
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__913be26bbb3ca9a624b25935110fbfb15f03fbd9796883e032331c23089bc1c8)
            check_type(argname="argument package_name", value=package_name, expected_type=type_hints["package_name"])
        options = NamedPackageOptions(
            service_restart_handles=service_restart_handles, version=version
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "python", [package_name, options]))

    @jsii.member(jsii_name="rpm")
    @builtins.classmethod
    def rpm(
        cls,
        location: builtins.str,
        *,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
    ) -> "InitPackage":
        '''Install an RPM from an HTTP URL or a location on disk.

        :param location: -
        :param key: Identifier key for this package. You can use this to order package installs. Default: - Automatically generated
        :param service_restart_handles: Restart the given service after this command has run. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c28cb8df7ec4dc1fc9206d5c20fa38a87e439c07fbab7318f5b7ddb144c7bccc)
            check_type(argname="argument location", value=location, expected_type=type_hints["location"])
        options = LocationPackageOptions(
            key=key, service_restart_handles=service_restart_handles
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "rpm", [location, options]))

    @jsii.member(jsii_name="rubyGem")
    @builtins.classmethod
    def ruby_gem(
        cls,
        gem_name: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        version: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "InitPackage":
        '''Install a package from RubyGems.

        :param gem_name: -
        :param service_restart_handles: Restart the given services after this command has run. Default: - Do not restart any service
        :param version: Specify the versions to install. Default: - Install the latest version
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a07707dc0fb1bf4e8e3d95b7727f81b9d8902e14aa0c0aba2524706eca1cb5c3)
            check_type(argname="argument gem_name", value=gem_name, expected_type=type_hints["gem_name"])
        options = NamedPackageOptions(
            service_restart_handles=service_restart_handles, version=version
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "rubyGem", [gem_name, options]))

    @jsii.member(jsii_name="yum")
    @builtins.classmethod
    def yum(
        cls,
        package_name: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence["InitServiceRestartHandle"]] = None,
        version: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "InitPackage":
        '''Install a package using Yum.

        :param package_name: -
        :param service_restart_handles: Restart the given services after this command has run. Default: - Do not restart any service
        :param version: Specify the versions to install. Default: - Install the latest version
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2a3727125d45f864366f97be2799e07039fb0b3c2b16c16dcf6995786c30d92)
            check_type(argname="argument package_name", value=package_name, expected_type=type_hints["package_name"])
        options = NamedPackageOptions(
            service_restart_handles=service_restart_handles, version=version
        )

        return typing.cast("InitPackage", jsii.sinvoke(cls, "yum", [package_name, options]))

    @jsii.member(jsii_name="renderPackageVersions")
    def _render_package_versions(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.invoke(self, "renderPackageVersions", []))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


class InitService(
    InitElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitService",
):
    '''A services that be enabled, disabled or restarted when the instance is launched.

    :exampleMetadata: infused

    Example::

        # my_bucket: s3.Bucket
        
        
        handle = ec2.InitServiceRestartHandle()
        
        ec2.CloudFormationInit.from_elements(
            ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
            ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
            ec2.InitService.enable("nginx",
                service_restart_handle=handle
            ))
    '''

    @jsii.member(jsii_name="disable")
    @builtins.classmethod
    def disable(cls, service_name: builtins.str) -> "InitService":
        '''Disable and stop the given service.

        :param service_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96361796986e5070202d174d465472957234a071d81bb170369a1834103264ee)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
        return typing.cast("InitService", jsii.sinvoke(cls, "disable", [service_name]))

    @jsii.member(jsii_name="enable")
    @builtins.classmethod
    def enable(
        cls,
        service_name: builtins.str,
        *,
        enabled: typing.Optional[builtins.bool] = None,
        ensure_running: typing.Optional[builtins.bool] = None,
        service_manager: typing.Optional["ServiceManager"] = None,
        service_restart_handle: typing.Optional["InitServiceRestartHandle"] = None,
    ) -> "InitService":
        '''Enable and start the given service, optionally restarting it.

        :param service_name: -
        :param enabled: Enable or disable this service. Set to true to ensure that the service will be started automatically upon boot. Set to false to ensure that the service will not be started automatically upon boot. Default: - true if used in ``InitService.enable()``, no change to service state if used in ``InitService.fromOptions()``.
        :param ensure_running: Make sure this service is running or not running after cfn-init finishes. Set to true to ensure that the service is running after cfn-init finishes. Set to false to ensure that the service is not running after cfn-init finishes. Default: - same value as ``enabled``.
        :param service_manager: What service manager to use. This needs to match the actual service manager on your Operating System. For example, Amazon Linux 1 uses SysVinit, but Amazon Linux 2 uses Systemd. Default: ServiceManager.SYSVINIT for Linux images, ServiceManager.WINDOWS for Windows images
        :param service_restart_handle: Restart service when the actions registered into the restartHandle have been performed. Register actions into the restartHandle by passing it to ``InitFile``, ``InitCommand``, ``InitPackage`` and ``InitSource`` objects. Default: - No files trigger restart
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__670f265ada6fe43ced07b09f682ad5ea1d9725b30f5c48bdc02351768c98388e)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
        options = InitServiceOptions(
            enabled=enabled,
            ensure_running=ensure_running,
            service_manager=service_manager,
            service_restart_handle=service_restart_handle,
        )

        return typing.cast("InitService", jsii.sinvoke(cls, "enable", [service_name, options]))

    @jsii.member(jsii_name="systemdConfigFile")
    @builtins.classmethod
    def systemd_config_file(
        cls,
        service_name: builtins.str,
        *,
        command: builtins.str,
        after_network: typing.Optional[builtins.bool] = None,
        cwd: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        group: typing.Optional[builtins.str] = None,
        keep_running: typing.Optional[builtins.bool] = None,
        user: typing.Optional[builtins.str] = None,
    ) -> InitFile:
        '''Install a systemd-compatible config file for the given service.

        This is a helper function to create a simple systemd configuration
        file that will allow running a service on the machine using ``InitService.enable()``.

        Systemd allows many configuration options; this function does not pretend
        to expose all of them. If you need advanced configuration options, you
        can use ``InitFile`` to create exactly the configuration file you need
        at ``/etc/systemd/system/${serviceName}.service``.

        :param service_name: -
        :param command: The command to run to start this service.
        :param after_network: Start the service after the networking part of the OS comes up. Default: true
        :param cwd: The working directory for the command. Default: Root directory or home directory of specified user
        :param description: A description of this service. Default: - No description
        :param group: The group to execute the process under. Default: root
        :param keep_running: Keep the process running all the time. Restarts the process when it exits for any reason other than the machine shutting down. Default: true
        :param user: The user to execute the process under. Default: root
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7573da52a8ea62c2b8aa64f8feb7a4a47ba65a4cac431430e05fdcee0b1ca060)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
        options = SystemdConfigFileOptions(
            command=command,
            after_network=after_network,
            cwd=cwd,
            description=description,
            group=group,
            keep_running=keep_running,
            user=user,
        )

        return typing.cast(InitFile, jsii.sinvoke(cls, "systemdConfigFile", [service_name, options]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitServiceOptions",
    jsii_struct_bases=[],
    name_mapping={
        "enabled": "enabled",
        "ensure_running": "ensureRunning",
        "service_manager": "serviceManager",
        "service_restart_handle": "serviceRestartHandle",
    },
)
class InitServiceOptions:
    def __init__(
        self,
        *,
        enabled: typing.Optional[builtins.bool] = None,
        ensure_running: typing.Optional[builtins.bool] = None,
        service_manager: typing.Optional["ServiceManager"] = None,
        service_restart_handle: typing.Optional["InitServiceRestartHandle"] = None,
    ) -> None:
        '''Options for an InitService.

        :param enabled: Enable or disable this service. Set to true to ensure that the service will be started automatically upon boot. Set to false to ensure that the service will not be started automatically upon boot. Default: - true if used in ``InitService.enable()``, no change to service state if used in ``InitService.fromOptions()``.
        :param ensure_running: Make sure this service is running or not running after cfn-init finishes. Set to true to ensure that the service is running after cfn-init finishes. Set to false to ensure that the service is not running after cfn-init finishes. Default: - same value as ``enabled``.
        :param service_manager: What service manager to use. This needs to match the actual service manager on your Operating System. For example, Amazon Linux 1 uses SysVinit, but Amazon Linux 2 uses Systemd. Default: ServiceManager.SYSVINIT for Linux images, ServiceManager.WINDOWS for Windows images
        :param service_restart_handle: Restart service when the actions registered into the restartHandle have been performed. Register actions into the restartHandle by passing it to ``InitFile``, ``InitCommand``, ``InitPackage`` and ``InitSource`` objects. Default: - No files trigger restart

        :exampleMetadata: infused

        Example::

            # my_bucket: s3.Bucket
            
            
            handle = ec2.InitServiceRestartHandle()
            
            ec2.CloudFormationInit.from_elements(
                ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
                ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
                ec2.InitService.enable("nginx",
                    service_restart_handle=handle
                ))
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__888d94950f15c9fd72ec8d35d2152d9acb230c63776b472d34136e20fa352507)
            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            check_type(argname="argument ensure_running", value=ensure_running, expected_type=type_hints["ensure_running"])
            check_type(argname="argument service_manager", value=service_manager, expected_type=type_hints["service_manager"])
            check_type(argname="argument service_restart_handle", value=service_restart_handle, expected_type=type_hints["service_restart_handle"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if enabled is not None:
            self._values["enabled"] = enabled
        if ensure_running is not None:
            self._values["ensure_running"] = ensure_running
        if service_manager is not None:
            self._values["service_manager"] = service_manager
        if service_restart_handle is not None:
            self._values["service_restart_handle"] = service_restart_handle

    @builtins.property
    def enabled(self) -> typing.Optional[builtins.bool]:
        '''Enable or disable this service.

        Set to true to ensure that the service will be started automatically upon boot.

        Set to false to ensure that the service will not be started automatically upon boot.

        :default:

        - true if used in ``InitService.enable()``, no change to service
        state if used in ``InitService.fromOptions()``.
        '''
        result = self._values.get("enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ensure_running(self) -> typing.Optional[builtins.bool]:
        '''Make sure this service is running or not running after cfn-init finishes.

        Set to true to ensure that the service is running after cfn-init finishes.

        Set to false to ensure that the service is not running after cfn-init finishes.

        :default: - same value as ``enabled``.
        '''
        result = self._values.get("ensure_running")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def service_manager(self) -> typing.Optional["ServiceManager"]:
        '''What service manager to use.

        This needs to match the actual service manager on your Operating System.
        For example, Amazon Linux 1 uses SysVinit, but Amazon Linux 2 uses Systemd.

        :default: ServiceManager.SYSVINIT for Linux images, ServiceManager.WINDOWS for Windows images
        '''
        result = self._values.get("service_manager")
        return typing.cast(typing.Optional["ServiceManager"], result)

    @builtins.property
    def service_restart_handle(self) -> typing.Optional["InitServiceRestartHandle"]:
        '''Restart service when the actions registered into the restartHandle have been performed.

        Register actions into the restartHandle by passing it to ``InitFile``, ``InitCommand``,
        ``InitPackage`` and ``InitSource`` objects.

        :default: - No files trigger restart
        '''
        result = self._values.get("service_restart_handle")
        return typing.cast(typing.Optional["InitServiceRestartHandle"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitServiceOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class InitServiceRestartHandle(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitServiceRestartHandle",
):
    '''An object that represents reasons to restart an InitService.

    Pass an instance of this object to the ``InitFile``, ``InitCommand``,
    ``InitSource`` and ``InitPackage`` objects, and finally to an ``InitService``
    itself to cause the actions (files, commands, sources, and packages)
    to trigger a restart of the service.

    For example, the following will run a custom command to install Nginx,
    and trigger the nginx service to be restarted after the command has run::

       handle = ec2.InitServiceRestartHandle()
       ec2.CloudFormationInit.from_elements(
           ec2.InitCommand.shell_command("/usr/bin/custom-nginx-install.sh", service_restart_handles=[handle]),
           ec2.InitService.enable("nginx", service_restart_handle=handle))

    :exampleMetadata: infused

    Example::

        # my_bucket: s3.Bucket
        
        
        handle = ec2.InitServiceRestartHandle()
        
        ec2.CloudFormationInit.from_elements(
            ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
            ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
            ec2.InitService.enable("nginx",
                service_restart_handle=handle
            ))
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])


class InitSource(
    InitElement,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.InitSource",
):
    '''Extract an archive into a directory.

    :exampleMetadata: infused

    Example::

        # my_bucket: s3.Bucket
        
        
        handle = ec2.InitServiceRestartHandle()
        
        ec2.CloudFormationInit.from_elements(
            ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
            ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
            ec2.InitService.enable("nginx",
                service_restart_handle=handle
            ))
    '''

    def __init__(
        self,
        target_directory: builtins.str,
        service_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> None:
        '''
        :param target_directory: -
        :param service_handles: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__34231d9e8a364e89679bb8edf9b26534ebde41c89266b71ca3f232de4ebf58a5)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument service_handles", value=service_handles, expected_type=type_hints["service_handles"])
        jsii.create(self.__class__, self, [target_directory, service_handles])

    @jsii.member(jsii_name="fromAsset")
    @builtins.classmethod
    def from_asset(
        cls,
        target_directory: builtins.str,
        path: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        deploy_time: typing.Optional[builtins.bool] = None,
        readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
        asset_hash: typing.Optional[builtins.str] = None,
        asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
        bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
        follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
        ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
    ) -> "InitSource":
        '''Create an InitSource from an asset created from the given path.

        :param target_directory: -
        :param path: -
        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
        :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.
        :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
        :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
        :param exclude: File paths matching the patterns will be excluded. See ``ignoreMode`` to set the matching behavior. Has no effect on Assets bundled using the ``bundling`` property. Default: - nothing is excluded
        :param follow_symlinks: A strategy for how to handle symlinks. Default: SymlinkFollowMode.NEVER
        :param ignore_mode: The ignore behavior to use for ``exclude`` patterns. Default: IgnoreMode.GLOB
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28af50587b7c2068b2cb49dbac75ce38a6ffdaf070d2c430abde336ae451307d)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        options = InitSourceAssetOptions(
            service_restart_handles=service_restart_handles,
            deploy_time=deploy_time,
            readers=readers,
            asset_hash=asset_hash,
            asset_hash_type=asset_hash_type,
            bundling=bundling,
            exclude=exclude,
            follow_symlinks=follow_symlinks,
            ignore_mode=ignore_mode,
        )

        return typing.cast("InitSource", jsii.sinvoke(cls, "fromAsset", [target_directory, path, options]))

    @jsii.member(jsii_name="fromExistingAsset")
    @builtins.classmethod
    def from_existing_asset(
        cls,
        target_directory: builtins.str,
        asset: _Asset_ac2a7e61,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> "InitSource":
        '''Extract a directory from an existing directory asset.

        :param target_directory: -
        :param asset: -
        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b63a5ea7edeb5864739aae02a3d234ecb2a030c9f682594007c315631d06df07)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument asset", value=asset, expected_type=type_hints["asset"])
        options = InitSourceOptions(service_restart_handles=service_restart_handles)

        return typing.cast("InitSource", jsii.sinvoke(cls, "fromExistingAsset", [target_directory, asset, options]))

    @jsii.member(jsii_name="fromGitHub")
    @builtins.classmethod
    def from_git_hub(
        cls,
        target_directory: builtins.str,
        owner: builtins.str,
        repo: builtins.str,
        ref_spec: typing.Optional[builtins.str] = None,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> "InitSource":
        '''Extract a GitHub branch into a given directory.

        :param target_directory: -
        :param owner: -
        :param repo: -
        :param ref_spec: -
        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1227483406e9a8b520fcc1607f7d7a112bf28c2d58603119c9e1086fe1e94dc)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
            check_type(argname="argument repo", value=repo, expected_type=type_hints["repo"])
            check_type(argname="argument ref_spec", value=ref_spec, expected_type=type_hints["ref_spec"])
        options = InitSourceOptions(service_restart_handles=service_restart_handles)

        return typing.cast("InitSource", jsii.sinvoke(cls, "fromGitHub", [target_directory, owner, repo, ref_spec, options]))

    @jsii.member(jsii_name="fromS3Object")
    @builtins.classmethod
    def from_s3_object(
        cls,
        target_directory: builtins.str,
        bucket: _IBucket_42e086fd,
        key: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> "InitSource":
        '''Extract an archive stored in an S3 bucket into the given directory.

        :param target_directory: -
        :param bucket: -
        :param key: -
        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d57fbeaaaf4f2e9f871791185f997d8e6be218eb5d477a01677ab6512ee819ed)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        options = InitSourceOptions(service_restart_handles=service_restart_handles)

        return typing.cast("InitSource", jsii.sinvoke(cls, "fromS3Object", [target_directory, bucket, key, options]))

    @jsii.member(jsii_name="fromUrl")
    @builtins.classmethod
    def from_url(
        cls,
        target_directory: builtins.str,
        url: builtins.str,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> "InitSource":
        '''Retrieve a URL and extract it into the given directory.

        :param target_directory: -
        :param url: -
        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b751c7df3427bb50b6bbc41011ecf565eba0ea4785bf1192150991e661feb5c8)
            check_type(argname="argument target_directory", value=target_directory, expected_type=type_hints["target_directory"])
            check_type(argname="argument url", value=url, expected_type=type_hints["url"])
        options = InitSourceOptions(service_restart_handles=service_restart_handles)

        return typing.cast("InitSource", jsii.sinvoke(cls, "fromUrl", [target_directory, url, options]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


class _InitSourceProxy(
    InitSource,
    jsii.proxy_for(InitElement), # type: ignore[misc]
):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, InitSource).__jsii_proxy_class__ = lambda : _InitSourceProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitSourceOptions",
    jsii_struct_bases=[],
    name_mapping={"service_restart_handles": "serviceRestartHandles"},
)
class InitSourceOptions:
    def __init__(
        self,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> None:
        '''Additional options for an InitSource.

        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service

        :exampleMetadata: infused

        Example::

            # my_bucket: s3.Bucket
            
            
            handle = ec2.InitServiceRestartHandle()
            
            ec2.CloudFormationInit.from_elements(
                ec2.InitFile.from_string("/etc/nginx/nginx.conf", "...", service_restart_handles=[handle]),
                ec2.InitSource.from_s3_object("/var/www/html", my_bucket, "html.zip", service_restart_handles=[handle]),
                ec2.InitService.enable("nginx",
                    service_restart_handle=handle
                ))
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c945323fe384c489cabde7df1d5d48da0402722153563ada43b0794dde492e70)
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List[InitServiceRestartHandle]]:
        '''Restart the given services after this archive has been extracted.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List[InitServiceRestartHandle]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitSourceOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class InitUser(
    InitElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitUser",
):
    '''Create Linux/UNIX users and to assign user IDs.

    Users are created as non-interactive system users with a shell of
    /sbin/nologin. This is by design and cannot be modified.

    Not supported for Windows systems.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        # machine_image: ec2.IMachineImage
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=machine_image,
        
            # Showing the most complex setup, if you have simpler requirements
            # you can use `CloudFormationInit.fromElements()`.
            init=ec2.CloudFormationInit.from_config_sets(
                config_sets={
                    # Applies the configs below in this order
                    "default": ["yumPreinstall", "config"]
                },
                configs={
                    "yum_preinstall": ec2.InitConfig([
                        # Install an Amazon Linux package using yum
                        ec2.InitPackage.yum("git")
                    ]),
                    "config": ec2.InitConfig([
                        # Create a JSON file from tokens (can also create other files)
                        ec2.InitFile.from_object("/etc/stack.json", {
                            "stack_id": Stack.of(self).stack_id,
                            "stack_name": Stack.of(self).stack_name,
                            "region": Stack.of(self).region
                        }),
        
                        # Create a group and user
                        ec2.InitGroup.from_name("my-group"),
                        ec2.InitUser.from_name("my-user"),
        
                        # Install an RPM from the internet
                        ec2.InitPackage.rpm("http://mirrors.ukfast.co.uk/sites/dl.fedoraproject.org/pub/epel/8/Everything/x86_64/Packages/r/rubygem-git-1.5.0-2.el8.noarch.rpm")
                    ])
                }
            ),
            init_options=ec2.ApplyCloudFormationInitOptions(
                # Optional, which configsets to activate (['default'] by default)
                config_sets=["default"],
        
                # Optional, how long the installation is expected to take (5 minutes by default)
                timeout=Duration.minutes(30),
        
                # Optional, whether to include the --url argument when running cfn-init and cfn-signal commands (false by default)
                include_url=True,
        
                # Optional, whether to include the --role argument when running cfn-init and cfn-signal commands (false by default)
                include_role=True
            )
        )
    '''

    def __init__(
        self,
        user_name: builtins.str,
        *,
        groups: typing.Optional[typing.Sequence[builtins.str]] = None,
        home_dir: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param user_name: -
        :param groups: A list of group names. The user will be added to each group in the list. Default: the user is not associated with any groups.
        :param home_dir: The user's home directory. Default: assigned by the OS
        :param user_id: A user ID. The creation process fails if the user name exists with a different user ID. If the user ID is already assigned to an existing user the operating system may reject the creation request. Default: assigned by the OS
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e09968a4eba0339641c1769cf843d1960c52bd49baad08990ce9250575de43fe)
            check_type(argname="argument user_name", value=user_name, expected_type=type_hints["user_name"])
        user_options = InitUserOptions(
            groups=groups, home_dir=home_dir, user_id=user_id
        )

        jsii.create(self.__class__, self, [user_name, user_options])

    @jsii.member(jsii_name="fromName")
    @builtins.classmethod
    def from_name(
        cls,
        user_name: builtins.str,
        *,
        groups: typing.Optional[typing.Sequence[builtins.str]] = None,
        home_dir: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[jsii.Number] = None,
    ) -> "InitUser":
        '''Create a user from user name.

        :param user_name: -
        :param groups: A list of group names. The user will be added to each group in the list. Default: the user is not associated with any groups.
        :param home_dir: The user's home directory. Default: assigned by the OS
        :param user_id: A user ID. The creation process fails if the user name exists with a different user ID. If the user ID is already assigned to an existing user the operating system may reject the creation request. Default: assigned by the OS
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c27581c265d934daabe647b3a61428311285c1cd380571a1aa0dce63866c0dc9)
            check_type(argname="argument user_name", value=user_name, expected_type=type_hints["user_name"])
        options = InitUserOptions(groups=groups, home_dir=home_dir, user_id=user_id)

        return typing.cast("InitUser", jsii.sinvoke(cls, "fromName", [user_name, options]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitUserOptions",
    jsii_struct_bases=[],
    name_mapping={"groups": "groups", "home_dir": "homeDir", "user_id": "userId"},
)
class InitUserOptions:
    def __init__(
        self,
        *,
        groups: typing.Optional[typing.Sequence[builtins.str]] = None,
        home_dir: typing.Optional[builtins.str] = None,
        user_id: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Optional parameters used when creating a user.

        :param groups: A list of group names. The user will be added to each group in the list. Default: the user is not associated with any groups.
        :param home_dir: The user's home directory. Default: assigned by the OS
        :param user_id: A user ID. The creation process fails if the user name exists with a different user ID. If the user ID is already assigned to an existing user the operating system may reject the creation request. Default: assigned by the OS

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            init_user_options = ec2.InitUserOptions(
                groups=["groups"],
                home_dir="homeDir",
                user_id=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a0db662f4ed021da7805cde424c100768b198b77d6d6fc05d4a575fa7c7cff5f)
            check_type(argname="argument groups", value=groups, expected_type=type_hints["groups"])
            check_type(argname="argument home_dir", value=home_dir, expected_type=type_hints["home_dir"])
            check_type(argname="argument user_id", value=user_id, expected_type=type_hints["user_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if groups is not None:
            self._values["groups"] = groups
        if home_dir is not None:
            self._values["home_dir"] = home_dir
        if user_id is not None:
            self._values["user_id"] = user_id

    @builtins.property
    def groups(self) -> typing.Optional[typing.List[builtins.str]]:
        '''A list of group names.

        The user will be added to each group in the list.

        :default: the user is not associated with any groups.
        '''
        result = self._values.get("groups")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def home_dir(self) -> typing.Optional[builtins.str]:
        '''The user's home directory.

        :default: assigned by the OS
        '''
        result = self._values.get("home_dir")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def user_id(self) -> typing.Optional[jsii.Number]:
        '''A user ID.

        The creation process fails if the user name exists with a different user ID.
        If the user ID is already assigned to an existing user the operating system may
        reject the creation request.

        :default: assigned by the OS
        '''
        result = self._values.get("user_id")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitUserOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IInstance)
class Instance(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.Instance",
):
    '''This represents a single EC2 instance.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.IVpc
        
        lb = elb.LoadBalancer(self, "LB",
            vpc=vpc,
            internet_facing=True
        )
        
        # instance to add as the target for load balancer.
        instance = ec2.Instance(self, "targetInstance",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO),
            machine_image=ec2.AmazonLinuxImage(generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2)
        )
        lb.add_target(elb.InstanceTarget(instance))
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        instance_type: "InstanceType",
        machine_image: IMachineImage,
        vpc: IVpc,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        associate_public_ip_address: typing.Optional[builtins.bool] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
        detailed_monitoring: typing.Optional[builtins.bool] = None,
        init: typing.Optional[CloudFormationInit] = None,
        init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        instance_name: typing.Optional[builtins.str] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        propagate_tags_to_volume_on_creation: typing.Optional[builtins.bool] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        resource_signal_timeout: typing.Optional[_Duration_4839e8c3] = None,
        role: typing.Optional[_IRole_235f5d8e] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
        source_dest_check: typing.Optional[builtins.bool] = None,
        ssm_session_permissions: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
        user_data_causes_replacement: typing.Optional[builtins.bool] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param instance_type: Type of instance to launch.
        :param machine_image: AMI to launch.
        :param vpc: VPC to launch the instance in.
        :param allow_all_ipv6_outbound: Whether the instance could initiate IPv6 connections to anywhere by default. This property is only used when you do not provide a security group. Default: false
        :param allow_all_outbound: Whether the instance could initiate connections to anywhere by default. This property is only used when you do not provide a security group. Default: true
        :param associate_public_ip_address: Whether to associate a public IP address to the primary network interface attached to this instance. Default: - public IP address is automatically assigned based on default behavior
        :param availability_zone: In which AZ to place the instance within the VPC. Default: - Random zone.
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param detailed_monitoring: Whether "Detailed Monitoring" is enabled for this instance Keep in mind that Detailed Monitoring results in extra charges. Default: - false
        :param init: Apply the given CloudFormation Init configuration to the instance at startup. Default: - no CloudFormation init
        :param init_options: Use the given options for applying CloudFormation Init. Describes the configsets to use and the timeout to wait Default: - default options
        :param instance_name: The name of the instance. Default: - CDK generated name
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param private_ip_address: Defines a private IP address to associate with an instance. Private IP should be available within the VPC that the instance is build within. Default: - no association
        :param propagate_tags_to_volume_on_creation: Propagate the EC2 instance tags to the EBS volumes. Default: - false
        :param require_imdsv2: Whether IMDSv2 should be required on this instance. Default: - false
        :param resource_signal_timeout: The length of time to wait for the resourceSignalCount. The maximum value is 43200 (12 hours). Default: Duration.minutes(5)
        :param role: An IAM role to associate with the instance profile assigned to this Auto Scaling Group. The role must be assumable by the service principal ``ec2.amazonaws.com``: Default: - A role will automatically be created, it can be accessed via the ``role`` property
        :param security_group: Security Group to assign to this instance. Default: - create new security group
        :param source_dest_check: Specifies whether to enable an instance launched in a VPC to perform NAT. This controls whether source/destination checking is enabled on the instance. A value of true means that checking is enabled, and false means that checking is disabled. The value must be false for the instance to perform NAT. Default: true
        :param ssm_session_permissions: Add SSM session permissions to the instance role. Setting this to ``true`` adds the necessary permissions to connect to the instance using SSM Session Manager. You can do this from the AWS Console. NOTE: Setting this flag to ``true`` may not be enough by itself. You must also use an AMI that comes with the SSM Agent, or install the SSM Agent yourself. See `Working with SSM Agent <https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html>`_ in the SSM Developer Guide. Default: false
        :param user_data: Specific UserData to use. The UserData may still be mutated after creation. Default: - A UserData object appropriate for the MachineImage's Operating System is created.
        :param user_data_causes_replacement: Changes to the UserData force replacement. Depending the EC2 instance type, changing UserData either restarts the instance or replaces the instance. - Instance store-backed instances are replaced. - EBS-backed instances are restarted. By default, restarting does not execute the new UserData so you will need a different mechanism to ensure the instance is restarted. Setting this to ``true`` will make the instance's Logical ID depend on the UserData, which will cause CloudFormation to replace it if the UserData changes. Default: - true iff ``initOptions`` is specified, false otherwise.
        :param vpc_subnets: Where to place the instance within the VPC. Default: - Private subnets.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5fdf31f5ae2497c7efcb56df558011698f38dc19cff28ca7a78a08a6d0ecc8e1)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = InstanceProps(
            instance_type=instance_type,
            machine_image=machine_image,
            vpc=vpc,
            allow_all_ipv6_outbound=allow_all_ipv6_outbound,
            allow_all_outbound=allow_all_outbound,
            associate_public_ip_address=associate_public_ip_address,
            availability_zone=availability_zone,
            block_devices=block_devices,
            detailed_monitoring=detailed_monitoring,
            init=init,
            init_options=init_options,
            instance_name=instance_name,
            key_name=key_name,
            key_pair=key_pair,
            private_ip_address=private_ip_address,
            propagate_tags_to_volume_on_creation=propagate_tags_to_volume_on_creation,
            require_imdsv2=require_imdsv2,
            resource_signal_timeout=resource_signal_timeout,
            role=role,
            security_group=security_group,
            source_dest_check=source_dest_check,
            ssm_session_permissions=ssm_session_permissions,
            user_data=user_data,
            user_data_causes_replacement=user_data_causes_replacement,
            vpc_subnets=vpc_subnets,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addSecurityGroup")
    def add_security_group(self, security_group: ISecurityGroup) -> None:
        '''Add the security group to the instance.

        :param security_group: : The security group to add.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4f65a4eef2e405cd6738f4385dbe842a34ca38633b5632ab1201159a686980f5)
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
        return typing.cast(None, jsii.invoke(self, "addSecurityGroup", [security_group]))

    @jsii.member(jsii_name="addToRolePolicy")
    def add_to_role_policy(self, statement: _PolicyStatement_0fe33853) -> None:
        '''Adds a statement to the IAM role assumed by the instance.

        :param statement: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__515ae0d6edde8aae452bc3424eb0155e73288a314bf836395c6ce27e4194efa9)
            check_type(argname="argument statement", value=statement, expected_type=type_hints["statement"])
        return typing.cast(None, jsii.invoke(self, "addToRolePolicy", [statement]))

    @jsii.member(jsii_name="addUserData")
    def add_user_data(self, *commands: builtins.str) -> None:
        '''Add command to the startup script of the instance.

        The command must be in the scripting language supported by the instance's OS (i.e. Linux/Windows).

        :param commands: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82601f36068811ad664f607ef04191e661dad31e73a2a8f4f2c40217ffa18b3d)
            check_type(argname="argument commands", value=commands, expected_type=typing.Tuple[type_hints["commands"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addUserData", [*commands]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''Allows specify security group connections for the instance.'''
        return typing.cast("Connections", jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="grantPrincipal")
    def grant_principal(self) -> _IPrincipal_539bb2fd:
        '''The principal to grant permissions to.'''
        return typing.cast(_IPrincipal_539bb2fd, jsii.get(self, "grantPrincipal"))

    @builtins.property
    @jsii.member(jsii_name="instance")
    def instance(self) -> CfnInstance:
        '''the underlying instance resource.'''
        return typing.cast(CfnInstance, jsii.get(self, "instance"))

    @builtins.property
    @jsii.member(jsii_name="instanceAvailabilityZone")
    def instance_availability_zone(self) -> builtins.str:
        '''The availability zone the instance was launched in.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The instance's ID.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceId"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateDnsName")
    def instance_private_dns_name(self) -> builtins.str:
        '''Private DNS name for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateIp")
    def instance_private_ip(self) -> builtins.str:
        '''Private IP for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateIp"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicDnsName")
    def instance_public_dns_name(self) -> builtins.str:
        '''Publicly-routable DNS name for this instance.

        (May be an empty string if the instance does not have a public name).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicIp")
    def instance_public_ip(self) -> builtins.str:
        '''Publicly-routable IP  address for this instance.

        (May be an empty string if the instance does not have a public IP).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicIp"))

    @builtins.property
    @jsii.member(jsii_name="osType")
    def os_type(self) -> "OperatingSystemType":
        '''The type of OS the instance is running.'''
        return typing.cast("OperatingSystemType", jsii.get(self, "osType"))

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> _IRole_235f5d8e:
        '''The IAM role assumed by the instance.'''
        return typing.cast(_IRole_235f5d8e, jsii.get(self, "role"))

    @builtins.property
    @jsii.member(jsii_name="userData")
    def user_data(self) -> "UserData":
        '''UserData for the instance.'''
        return typing.cast("UserData", jsii.get(self, "userData"))


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.InstanceArchitecture")
class InstanceArchitecture(enum.Enum):
    '''Identifies an instance's CPU architecture.'''

    ARM_64 = "ARM_64"
    '''ARM64 architecture.'''
    X86_64 = "X86_64"
    '''x86-64 architecture.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.InstanceClass")
class InstanceClass(enum.Enum):
    '''What class and generation of instance to use.

    We have both symbolic and concrete enums for every type.

    The first are for people that want to specify by purpose,
    the second one are for people who already know exactly what
    'R4' means.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        cluster = rds.DatabaseCluster(self, "Database",
            engine=rds.DatabaseClusterEngine.aurora_mysql(version=rds.AuroraMysqlEngineVersion.VER_3_01_0),
            writer=rds.ClusterInstance.provisioned("Instance",
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL)
            ),
            readers=[rds.ClusterInstance.provisioned("reader")],
            instance_update_behaviour=rds.InstanceUpdateBehaviour.ROLLING,  # Optional - defaults to rds.InstanceUpdateBehaviour.BULK
            vpc=vpc
        )
    '''

    STANDARD3 = "STANDARD3"
    '''Standard instances, 3rd generation.'''
    M3 = "M3"
    '''Standard instances, 3rd generation.'''
    STANDARD4 = "STANDARD4"
    '''Standard instances, 4th generation.'''
    M4 = "M4"
    '''Standard instances, 4th generation.'''
    STANDARD5 = "STANDARD5"
    '''Standard instances, 5th generation.'''
    M5 = "M5"
    '''Standard instances, 5th generation.'''
    STANDARD5_NVME_DRIVE = "STANDARD5_NVME_DRIVE"
    '''Standard instances with local NVME drive, 5th generation.'''
    M5D = "M5D"
    '''Standard instances with local NVME drive, 5th generation.'''
    STANDARD5_AMD = "STANDARD5_AMD"
    '''Standard instances based on AMD EPYC, 5th generation.'''
    M5A = "M5A"
    '''Standard instances based on AMD EPYC, 5th generation.'''
    STANDARD5_AMD_NVME_DRIVE = "STANDARD5_AMD_NVME_DRIVE"
    '''Standard instances based on AMD EPYC with local NVME drive, 5th generation.'''
    M5AD = "M5AD"
    '''Standard instances based on AMD EPYC with local NVME drive, 5th generation.'''
    STANDARD5_HIGH_PERFORMANCE = "STANDARD5_HIGH_PERFORMANCE"
    '''Standard instances for high performance computing, 5th generation.'''
    M5N = "M5N"
    '''Standard instances for high performance computing, 5th generation.'''
    STANDARD5_NVME_DRIVE_HIGH_PERFORMANCE = "STANDARD5_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Standard instances with local NVME drive for high performance computing, 5th generation.'''
    M5DN = "M5DN"
    '''Standard instances with local NVME drive for high performance computing, 5th generation.'''
    STANDARD5_HIGH_COMPUTE = "STANDARD5_HIGH_COMPUTE"
    '''Standard instances with high memory and compute capacity based on Intel Xeon Scalable (Cascade Lake) processors, 5nd generation.'''
    M5ZN = "M5ZN"
    '''Standard instances with high memory and compute capacity based on Intel Xeon Scalable (Cascade Lake) processors, 5nd generation.'''
    MEMORY3 = "MEMORY3"
    '''Memory optimized instances, 3rd generation.'''
    R3 = "R3"
    '''Memory optimized instances, 3rd generation.'''
    MEMORY4 = "MEMORY4"
    '''Memory optimized instances, 4th generation.'''
    R4 = "R4"
    '''Memory optimized instances, 4th generation.'''
    MEMORY5 = "MEMORY5"
    '''Memory optimized instances, 5th generation.'''
    R5 = "R5"
    '''Memory optimized instances, 5th generation.'''
    MEMORY6_AMD = "MEMORY6_AMD"
    '''Memory optimized instances based on AMD EPYC, 6th generation.'''
    R6A = "R6A"
    '''Memory optimized instances based on AMD EPYC, 6th generation.'''
    MEMORY6_INTEL = "MEMORY6_INTEL"
    '''Memory optimized instances, 6th generation with Intel Xeon Scalable processors (3rd generation processors code named Ice Lake).'''
    R6I = "R6I"
    '''Memory optimized instances, 6th generation with Intel Xeon Scalable processors (3rd generation processors code named Ice Lake).'''
    MEMORY6_INTEL_NVME_DRIVE = "MEMORY6_INTEL_NVME_DRIVE"
    '''Memory optimized instances with local NVME drive, 6th generation with Intel Xeon Scalable processors (3rd generation processors code named Ice Lake).'''
    R6ID = "R6ID"
    '''Memory optimized instances with local NVME drive, 6th generation with Intel Xeon Scalable processors (3rd generation processors code named Ice Lake).'''
    MEMORY6_INTEL_HIGH_PERFORMANCE = "MEMORY6_INTEL_HIGH_PERFORMANCE"
    '''Memory optimized instances for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    R6IN = "R6IN"
    '''Memory optimized instances for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    MEMORY6_INTEL_NVME_DRIVE_HIGH_PERFORMANCE = "MEMORY6_INTEL_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Memory optimized instances with local NVME drive for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    R6IDN = "R6IDN"
    '''Memory optimized instances with local NVME drive for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    MEMORY5_HIGH_PERFORMANCE = "MEMORY5_HIGH_PERFORMANCE"
    '''Memory optimized instances for high performance computing, 5th generation.'''
    R5N = "R5N"
    '''Memory optimized instances for high performance computing, 5th generation.'''
    MEMORY5_NVME_DRIVE = "MEMORY5_NVME_DRIVE"
    '''Memory optimized instances with local NVME drive, 5th generation.'''
    R5D = "R5D"
    '''Memory optimized instances with local NVME drive, 5th generation.'''
    MEMORY5_NVME_DRIVE_HIGH_PERFORMANCE = "MEMORY5_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Memory optimized instances with local NVME drive for high performance computing, 5th generation.'''
    R5DN = "R5DN"
    '''Memory optimized instances with local NVME drive for high performance computing, 5th generation.'''
    MEMORY5_AMD = "MEMORY5_AMD"
    '''Memory optimized instances based on AMD EPYC, 5th generation.'''
    R5A = "R5A"
    '''Memory optimized instances based on AMD EPYC, 5th generation.'''
    MEMORY5_AMD_NVME_DRIVE = "MEMORY5_AMD_NVME_DRIVE"
    '''Memory optimized instances based on AMD EPYC with local NVME drive, 5th generation.'''
    HIGH_MEMORY_3TB_1 = "HIGH_MEMORY_3TB_1"
    '''High memory instances (3TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    U_3TB1 = "U_3TB1"
    '''High memory instances (3TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    HIGH_MEMORY_6TB_1 = "HIGH_MEMORY_6TB_1"
    '''High memory instances (6TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    U_6TB1 = "U_6TB1"
    '''High memory instances (6TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    HIGH_MEMORY_9TB_1 = "HIGH_MEMORY_9TB_1"
    '''High memory instances (9TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    U_9TB1 = "U_9TB1"
    '''High memory instances (9TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    HIGH_MEMORY_12TB_1 = "HIGH_MEMORY_12TB_1"
    '''High memory instances (12TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    U_12TB1 = "U_12TB1"
    '''High memory instances (12TB) based on Intel Xeon Platinum 8176M (Skylake) processors, 1st generation.'''
    HIGH_MEMORY_18TB_1 = "HIGH_MEMORY_18TB_1"
    '''High memory instances (18TB) based on Intel Xeon Scalable (Cascade Lake) processors, 1st generation.'''
    U_18TB1 = "U_18TB1"
    '''High memory instances (18TB) based on Intel Xeon Scalable (Cascade Lake) processors, 1st generation.'''
    HIGH_MEMORY_24TB_1 = "HIGH_MEMORY_24TB_1"
    '''High memory instances (24TB) based on Intel Xeon Scalable (Cascade Lake) processors, 1st generation.'''
    U_24TB1 = "U_24TB1"
    '''High memory instances (24TB) based on Intel Xeon Scalable (Cascade Lake) processors, 1st generation.'''
    R5AD = "R5AD"
    '''Memory optimized instances based on AMD EPYC with local NVME drive, 5th generation.'''
    MEMORY5_EBS_OPTIMIZED = "MEMORY5_EBS_OPTIMIZED"
    '''Memory optimized instances that are also EBS-optimized, 5th generation.'''
    R5B = "R5B"
    '''Memory optimized instances that are also EBS-optimized, 5th generation.'''
    MEMORY6_GRAVITON = "MEMORY6_GRAVITON"
    '''Memory optimized instances, 6th generation with Graviton2 processors.'''
    R6G = "R6G"
    '''Memory optimized instances, 6th generation with Graviton2 processors.'''
    MEMORY6_GRAVITON2_NVME_DRIVE = "MEMORY6_GRAVITON2_NVME_DRIVE"
    '''Memory optimized instances, 6th generation with Graviton2 processors and local NVME drive.'''
    R6GD = "R6GD"
    '''Memory optimized instances, 6th generation with Graviton2 processors and local NVME drive.'''
    MEMORY7_GRAVITON = "MEMORY7_GRAVITON"
    '''Memory optimized instances, 7th generation with Graviton3 processors.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    R7G = "R7G"
    '''Memory optimized instances, 7th generation with Graviton3 processors.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    MEMORY7_GRAVITON3_NVME_DRIVE = "MEMORY7_GRAVITON3_NVME_DRIVE"
    '''Memory optimized instances, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    R7GD = "R7GD"
    '''Memory optimized instances, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    MEMORY7_INTEL_BASE = "MEMORY7_INTEL_BASE"
    '''Memory optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation w/  3.2GHz turbo frequency.'''
    R7I = "R7I"
    '''Memory optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation w/  3.2GHz turbo frequency.'''
    MEMORY7_INTEL = "MEMORY7_INTEL"
    '''Memory optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation, with sustained 3.9GHz turbo frequency.'''
    R7IZ = "R7IZ"
    '''Memory optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation, with sustained 3.9GHz turbo frequency.'''
    MEMORY7_AMD = "MEMORY7_AMD"
    '''Memory optimized instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    R7A = "R7A"
    '''Memory optimized instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    COMPUTE3 = "COMPUTE3"
    '''Compute optimized instances, 3rd generation.'''
    C3 = "C3"
    '''Compute optimized instances, 3rd generation.'''
    COMPUTE4 = "COMPUTE4"
    '''Compute optimized instances, 4th generation.'''
    C4 = "C4"
    '''Compute optimized instances, 4th generation.'''
    COMPUTE5 = "COMPUTE5"
    '''Compute optimized instances, 5th generation.'''
    C5 = "C5"
    '''Compute optimized instances, 5th generation.'''
    COMPUTE5_NVME_DRIVE = "COMPUTE5_NVME_DRIVE"
    '''Compute optimized instances with local NVME drive, 5th generation.'''
    C5D = "C5D"
    '''Compute optimized instances with local NVME drive, 5th generation.'''
    COMPUTE5_AMD = "COMPUTE5_AMD"
    '''Compute optimized instances based on AMD EPYC, 5th generation.'''
    C5A = "C5A"
    '''Compute optimized instances based on AMD EPYC, 5th generation.'''
    COMPUTE5_AMD_NVME_DRIVE = "COMPUTE5_AMD_NVME_DRIVE"
    '''Compute optimized instances with local NVME drive based on AMD EPYC, 5th generation.'''
    C5AD = "C5AD"
    '''Compute optimized instances with local NVME drive based on AMD EPYC, 5th generation.'''
    COMPUTE5_HIGH_PERFORMANCE = "COMPUTE5_HIGH_PERFORMANCE"
    '''Compute optimized instances for high performance computing, 5th generation.'''
    C5N = "C5N"
    '''Compute optimized instances for high performance computing, 5th generation.'''
    COMPUTE6_INTEL = "COMPUTE6_INTEL"
    '''Compute optimized instances, 6th generation.'''
    C6I = "C6I"
    '''Compute optimized instances, 6th generation.'''
    COMPUTE6_INTEL_NVME_DRIVE = "COMPUTE6_INTEL_NVME_DRIVE"
    '''Compute optimized instances with local NVME drive, 6th generation.'''
    C6ID = "C6ID"
    '''Compute optimized instances with local NVME drive, 6th generation.'''
    COMPUTE6_INTEL_HIGH_PERFORMANCE = "COMPUTE6_INTEL_HIGH_PERFORMANCE"
    '''Compute optimized instances for high performance computing, 6th generation.'''
    C6IN = "C6IN"
    '''Compute optimized instances for high performance computing, 6th generation.'''
    COMPUTE6_AMD = "COMPUTE6_AMD"
    '''Compute optimized instances based on AMD EPYC (codename Milan), 6th generation.'''
    C6A = "C6A"
    '''Compute optimized instances based on AMD EPYC (codename Milan), 6th generation.'''
    COMPUTE6_GRAVITON2 = "COMPUTE6_GRAVITON2"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors.'''
    C6G = "C6G"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors.'''
    COMPUTE7_GRAVITON3 = "COMPUTE7_GRAVITON3"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors.'''
    C7G = "C7G"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors.'''
    COMPUTE6_GRAVITON2_NVME_DRIVE = "COMPUTE6_GRAVITON2_NVME_DRIVE"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors and local NVME drive.'''
    C6GD = "C6GD"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors and local NVME drive.'''
    COMPUTE7_GRAVITON3_NVME_DRIVE = "COMPUTE7_GRAVITON3_NVME_DRIVE"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    C7GD = "C7GD"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    COMPUTE6_GRAVITON2_HIGH_NETWORK_BANDWIDTH = "COMPUTE6_GRAVITON2_HIGH_NETWORK_BANDWIDTH"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors and high network bandwidth capabilities.'''
    C6GN = "C6GN"
    '''Compute optimized instances for high performance computing, 6th generation with Graviton2 processors and high network bandwidth capabilities.'''
    COMPUTE7_GRAVITON3_HIGH_NETWORK_BANDWIDTH = "COMPUTE7_GRAVITON3_HIGH_NETWORK_BANDWIDTH"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors and high network bandwidth capabilities.'''
    C7GN = "C7GN"
    '''Compute optimized instances for high performance computing, 7th generation with Graviton3 processors and high network bandwidth capabilities.'''
    COMPUTE7_INTEL = "COMPUTE7_INTEL"
    '''Compute optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation.'''
    C7I = "C7I"
    '''Compute optimized instances based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation.'''
    COMPUTE7_AMD = "COMPUTE7_AMD"
    '''Compute optimized instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    C7A = "C7A"
    '''Compute optimized instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    STORAGE2 = "STORAGE2"
    '''Storage-optimized instances, 2nd generation.'''
    D2 = "D2"
    '''Storage-optimized instances, 2nd generation.'''
    STORAGE3 = "STORAGE3"
    '''Storage-optimized instances, 3rd generation.'''
    D3 = "D3"
    '''Storage-optimized instances, 3rd generation.'''
    STORAGE3_ENHANCED_NETWORK = "STORAGE3_ENHANCED_NETWORK"
    '''Storage-optimized instances, 3rd generation.'''
    D3EN = "D3EN"
    '''Storage-optimized instances, 3rd generation.'''
    STORAGE_COMPUTE_1 = "STORAGE_COMPUTE_1"
    '''Storage/compute balanced instances, 1st generation.'''
    TRN1 = "TRN1"
    '''High performance computing powered by AWS Trainium.'''
    TRN1N = "TRN1N"
    '''High performance computing powered by AWS Trainium.'''
    H1 = "H1"
    '''Storage/compute balanced instances, 1st generation.'''
    IO3 = "IO3"
    '''I/O-optimized instances, 3rd generation.'''
    I3 = "I3"
    '''I/O-optimized instances, 3rd generation.'''
    IO3_DENSE_NVME_DRIVE = "IO3_DENSE_NVME_DRIVE"
    '''I/O-optimized instances with local NVME drive, 3rd generation.'''
    I3EN = "I3EN"
    '''I/O-optimized instances with local NVME drive, 3rd generation.'''
    IO4_INTEL = "IO4_INTEL"
    '''I/O-optimized instances with local NVME drive powered by Intel Xeon Scalable processors (code named Ice Lake), 4th generation.'''
    I4I = "I4I"
    '''I/O-optimized instances with local NVME drive powered by Intel Xeon Scalable processors (code named Ice Lake), 4th generation.'''
    STORAGE4_GRAVITON = "STORAGE4_GRAVITON"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    I4G = "I4G"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    STORAGE4_GRAVITON_NETWORK_OPTIMIZED = "STORAGE4_GRAVITON_NETWORK_OPTIMIZED"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    IM4GN = "IM4GN"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    STORAGE4_GRAVITON_NETWORK_STORAGE_OPTIMIZED = "STORAGE4_GRAVITON_NETWORK_STORAGE_OPTIMIZED"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    IS4GEN = "IS4GEN"
    '''Storage optimized instances powered by Graviton2 processor, 4th generation.'''
    BURSTABLE2 = "BURSTABLE2"
    '''Burstable instances, 2nd generation.'''
    T2 = "T2"
    '''Burstable instances, 2nd generation.'''
    BURSTABLE3 = "BURSTABLE3"
    '''Burstable instances, 3rd generation.'''
    T3 = "T3"
    '''Burstable instances, 3rd generation.'''
    BURSTABLE3_AMD = "BURSTABLE3_AMD"
    '''Burstable instances based on AMD EPYC, 3rd generation.'''
    T3A = "T3A"
    '''Burstable instances based on AMD EPYC, 3rd generation.'''
    BURSTABLE4_GRAVITON = "BURSTABLE4_GRAVITON"
    '''Burstable instances, 4th generation with Graviton2 processors.'''
    T4G = "T4G"
    '''Burstable instances, 4th generation with Graviton2 processors.'''
    MEMORY_INTENSIVE_1 = "MEMORY_INTENSIVE_1"
    '''Memory-intensive instances, 1st generation.'''
    X1 = "X1"
    '''Memory-intensive instances, 1st generation.'''
    MEMORY_INTENSIVE_1_EXTENDED = "MEMORY_INTENSIVE_1_EXTENDED"
    '''Memory-intensive instances, extended, 1st generation.'''
    X1E = "X1E"
    '''Memory-intensive instances, 1st generation.'''
    MEMORY_INTENSIVE_2_GRAVITON2 = "MEMORY_INTENSIVE_2_GRAVITON2"
    '''Memory-intensive instances, 2nd generation with Graviton2 processors.

    This instance type can be used only in RDS. It is not supported in EC2.
    '''
    X2G = "X2G"
    '''Memory-intensive instances, 2nd generation with Graviton2 processors.

    This instance type can be used only in RDS. It is not supported in EC2.
    '''
    MEMORY_INTENSIVE_2_GRAVITON2_NVME_DRIVE = "MEMORY_INTENSIVE_2_GRAVITON2_NVME_DRIVE"
    '''Memory-intensive instances, 2nd generation with Graviton2 processors and local NVME drive.'''
    X2GD = "X2GD"
    '''Memory-intensive instances, 2nd generation with Graviton2 processors and local NVME drive.'''
    MEMORY_INTENSIVE_2_XT_INTEL = "MEMORY_INTENSIVE_2_XT_INTEL"
    '''Memory-intensive instances with higher network bandwith, local NVME drive, and extended memory.

    Intel Xeon Scalable (Ice Lake) processors
    '''
    X2IEDN = "X2IEDN"
    '''Memory-intensive instances with higher network bandwith, local NVME drive, and extended memory.

    Intel Xeon Scalable (Ice Lake) processors
    '''
    MEMORY_INTENSIVE_2_INTEL = "MEMORY_INTENSIVE_2_INTEL"
    '''Memory-intensive instances with higher network bandwith and local NVME drive, Intel Xeon Scalable (Ice Lake) processors.'''
    X2IDN = "X2IDN"
    '''Memory-intensive instances with higher network bandwith and local NVME drive, Intel Xeon Scalable (Ice Lake) processors.'''
    MEMORY_INTENSIVE_2_XTZ_INTEL = "MEMORY_INTENSIVE_2_XTZ_INTEL"
    '''Memory-intensive instances with higher network bandwith and single-threaded performance, Intel Xeon Scalable (Cascade Lake) processors.'''
    X2IEZN = "X2IEZN"
    '''Memory-intensive instances with higher network bandwith and single-threaded performance, Intel Xeon Scalable (Cascade Lake) processors.'''
    FPGA1 = "FPGA1"
    '''Instances with customizable hardware acceleration, 1st generation.'''
    F1 = "F1"
    '''Instances with customizable hardware acceleration, 1st generation.'''
    GRAPHICS3_SMALL = "GRAPHICS3_SMALL"
    '''Graphics-optimized instances, 3rd generation.'''
    G3S = "G3S"
    '''Graphics-optimized instances, 3rd generation.'''
    GRAPHICS3 = "GRAPHICS3"
    '''Graphics-optimized instances, 3rd generation.'''
    G3 = "G3"
    '''Graphics-optimized instances, 3rd generation.'''
    GRAPHICS4_NVME_DRIVE_HIGH_PERFORMANCE = "GRAPHICS4_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Graphics-optimized instances with NVME drive for high performance computing, 4th generation.'''
    G4DN = "G4DN"
    '''Graphics-optimized instances with NVME drive for high performance computing, 4th generation.'''
    GRAPHICS4_AMD_NVME_DRIVE = "GRAPHICS4_AMD_NVME_DRIVE"
    '''Graphics-optimized instances based on AMD EPYC And Radeon Pro GPU (NAVI) with local NVME drive, 4th generation.'''
    G4AD = "G4AD"
    '''Graphics-optimized instances based on AMD EPYC And Radeon Pro GPU (NAVI) with local NVME drive, 4th generation.'''
    GRAPHICS5 = "GRAPHICS5"
    '''Graphics-optimized instances, 5th generation.'''
    G5 = "G5"
    '''Graphics-optimized instances, 5th generation.'''
    GRAPHICS5_GRAVITON2 = "GRAPHICS5_GRAVITON2"
    '''Graphics-optimized instances powered by AWS Graviton2 Processors and NVIDIA T4G Tensor Core GPUs, 5th generation.'''
    G5G = "G5G"
    '''Graphics-optimized instances powered by AWS Graviton2 Processors and NVIDIA T4G Tensor Core GPUs, 5th generation.'''
    PARALLEL2 = "PARALLEL2"
    '''Parallel-processing optimized instances, 2nd generation.'''
    P2 = "P2"
    '''Parallel-processing optimized instances, 2nd generation.'''
    PARALLEL3 = "PARALLEL3"
    '''Parallel-processing optimized instances, 3nd generation.'''
    P3 = "P3"
    '''Parallel-processing optimized instances, 3rd generation.'''
    PARALLEL3_NVME_DRIVE_HIGH_PERFORMANCE = "PARALLEL3_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Parallel-processing optimized instances with local NVME drive for high performance computing, 3nd generation.'''
    P3DN = "P3DN"
    '''Parallel-processing optimized instances with local NVME drive for high performance computing, 3rd generation.'''
    PARALLEL4_NVME_DRIVE_EXTENDED = "PARALLEL4_NVME_DRIVE_EXTENDED"
    '''Parallel-processing optimized instances with local NVME drive, extended, 4th generation (in developer preview).'''
    P4DE = "P4DE"
    '''Parallel-processing optimized instances with local NVME drive, extended, 4th generation (in developer preview).'''
    PARALLEL4 = "PARALLEL4"
    '''Parallel-processing optimized instances, 4th generation.'''
    P4D = "P4D"
    '''Parallel-processing optimized instances, 4th generation.'''
    PARALLEL5 = "PARALLEL5"
    '''Parallel-processing optimized instances, 5th generation.'''
    P5 = "P5"
    '''Parallel-processing optimized instances, 5th generation.'''
    ARM1 = "ARM1"
    '''Arm processor based instances, 1st generation.'''
    A1 = "A1"
    '''Arm processor based instances, 1st generation.'''
    STANDARD6_GRAVITON = "STANDARD6_GRAVITON"
    '''Arm processor based instances, 2nd generation.'''
    M6G = "M6G"
    '''Arm processor based instances, 2nd generation.'''
    STANDARD6_INTEL = "STANDARD6_INTEL"
    '''Standard instances based on Intel (Ice Lake), 6th generation.'''
    M6I = "M6I"
    '''Standard instances based on Intel (Ice Lake), 6th generation.'''
    STANDARD6_INTEL_NVME_DRIVE = "STANDARD6_INTEL_NVME_DRIVE"
    '''Standard instances based on Intel (Ice Lake) with local NVME drive, 6th generation.'''
    M6ID = "M6ID"
    '''Standard instances based on Intel (Ice Lake) with local NVME drive, 6th generation.'''
    STANDARD6_INTEL_HIGH_PERFORMANCE = "STANDARD6_INTEL_HIGH_PERFORMANCE"
    '''Standard instances for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    M6IN = "M6IN"
    '''Standard instances for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    STANDARD6_INTEL_NVME_DRIVE_HIGH_PERFORMANCE = "STANDARD6_INTEL_NVME_DRIVE_HIGH_PERFORMANCE"
    '''Standard instances with local NVME drive for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    M6IDN = "M6IDN"
    '''Standard instances with local NVME drive for high performance computing powered by Intel Xeon Scalable processors (code named Ice Lake), 6th generation.'''
    STANDARD6_AMD = "STANDARD6_AMD"
    '''Standard instances based on 3rd Gen AMD EPYC processors, 6th generation.'''
    M6A = "M6A"
    '''Standard instances based on 3rd Gen AMD EPYC processors, 6th generation.'''
    STANDARD6_GRAVITON2_NVME_DRIVE = "STANDARD6_GRAVITON2_NVME_DRIVE"
    '''Standard instances, 6th generation with Graviton2 processors and local NVME drive.'''
    M6GD = "M6GD"
    '''Standard instances, 6th generation with Graviton2 processors and local NVME drive.'''
    STANDARD7_GRAVITON = "STANDARD7_GRAVITON"
    '''Standard instances, 7th generation with Graviton3 processors.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    M7G = "M7G"
    '''Standard instances, 7th generation with Graviton3 processors.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    STANDARD7_GRAVITON3_NVME_DRIVE = "STANDARD7_GRAVITON3_NVME_DRIVE"
    '''Standard instances, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    M7GD = "M7GD"
    '''Standard instances, 7th generation with Graviton3 processors and local NVME drive.

    This instance class is currently only available in US East (Ohio), US East (N. Virginia), US West (Oregon), and Europe (Ireland).
    '''
    STANDARD7_INTEL = "STANDARD7_INTEL"
    '''Standard instances with high memory and compute capacity based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation.'''
    M7I = "M7I"
    '''Standard instances with high memory and compute capacity based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation.'''
    STANDARD7_INTEL_FLEX = "STANDARD7_INTEL_FLEX"
    '''Flexible instances with high memory and compute capacity based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation The M7i-Flex instances deliver a baseline of 40% CPU performance, and can scale up to full CPU performance 95% of the time.'''
    M7I_FLEX = "M7I_FLEX"
    '''Flexible instances with high memory and compute capacity based on Intel Xeon Scalable (Sapphire Rapids) processors, 7th generation The M7i-Flex instances deliver a baseline of 40% CPU performance, and can scale up to full CPU performance 95% of the time.'''
    STANDARD7_AMD = "STANDARD7_AMD"
    '''Standard instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    M7A = "M7A"
    '''Standard instances based on 4th generation AMD EPYC (codename Genoa), 7th generation.'''
    HIGH_COMPUTE_MEMORY1 = "HIGH_COMPUTE_MEMORY1"
    '''High memory and compute capacity instances, 1st generation.'''
    Z1D = "Z1D"
    '''High memory and compute capacity instances, 1st generation.'''
    INFERENCE1 = "INFERENCE1"
    '''Inferentia Chips based instances for machine learning inference applications, 1st generation.'''
    INF1 = "INF1"
    '''Inferentia Chips based instances for machine learning inference applications, 1st generation.'''
    INFERENCE2 = "INFERENCE2"
    '''Inferentia Chips based instances for machine learning inference applications, 2nd generation.'''
    INF2 = "INF2"
    '''Inferentia Chips based instances for machine learning inference applications, 2nd generation.'''
    MACINTOSH1_INTEL = "MACINTOSH1_INTEL"
    '''Macintosh instances built on Apple Mac mini computers, 1st generation with Intel procesors.'''
    MAC1 = "MAC1"
    '''Macintosh instances built on Apple Mac mini computers, 1st generation with Intel procesors.'''
    VIDEO_TRANSCODING1 = "VIDEO_TRANSCODING1"
    '''Multi-stream video transcoding instances for resolutions up to 4K UHD, 1st generation.'''
    VT1 = "VT1"
    '''Multi-stream video transcoding instances for resolutions up to 4K UHD, 1st generation.'''
    HIGH_PERFORMANCE_COMPUTING6_AMD = "HIGH_PERFORMANCE_COMPUTING6_AMD"
    '''High performance computing based on AMD EPYC, 6th generation.'''
    HPC6A = "HPC6A"
    '''High performance computing based on AMD EPYC, 6th generation.'''
    DEEP_LEARNING1 = "DEEP_LEARNING1"
    '''Deep learning instances powered by Gaudi accelerators from Habana Labs (an Intel company), 1st generation.'''
    DL1 = "DL1"
    '''Deep learning instances powered by Gaudi accelerators from Habana Labs (an Intel company), 1st generation.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.InstanceInitiatedShutdownBehavior")
class InstanceInitiatedShutdownBehavior(enum.Enum):
    '''Provides the options for specifying the instance initiated shutdown behavior.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior
    '''

    STOP = "STOP"
    '''The instance will stop when it initiates a shutdown.'''
    TERMINATE = "TERMINATE"
    '''The instance will be terminated when it initiates a shutdown.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InstanceProps",
    jsii_struct_bases=[],
    name_mapping={
        "instance_type": "instanceType",
        "machine_image": "machineImage",
        "vpc": "vpc",
        "allow_all_ipv6_outbound": "allowAllIpv6Outbound",
        "allow_all_outbound": "allowAllOutbound",
        "associate_public_ip_address": "associatePublicIpAddress",
        "availability_zone": "availabilityZone",
        "block_devices": "blockDevices",
        "detailed_monitoring": "detailedMonitoring",
        "init": "init",
        "init_options": "initOptions",
        "instance_name": "instanceName",
        "key_name": "keyName",
        "key_pair": "keyPair",
        "private_ip_address": "privateIpAddress",
        "propagate_tags_to_volume_on_creation": "propagateTagsToVolumeOnCreation",
        "require_imdsv2": "requireImdsv2",
        "resource_signal_timeout": "resourceSignalTimeout",
        "role": "role",
        "security_group": "securityGroup",
        "source_dest_check": "sourceDestCheck",
        "ssm_session_permissions": "ssmSessionPermissions",
        "user_data": "userData",
        "user_data_causes_replacement": "userDataCausesReplacement",
        "vpc_subnets": "vpcSubnets",
    },
)
class InstanceProps:
    def __init__(
        self,
        *,
        instance_type: "InstanceType",
        machine_image: IMachineImage,
        vpc: IVpc,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        associate_public_ip_address: typing.Optional[builtins.bool] = None,
        availability_zone: typing.Optional[builtins.str] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
        detailed_monitoring: typing.Optional[builtins.bool] = None,
        init: typing.Optional[CloudFormationInit] = None,
        init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        instance_name: typing.Optional[builtins.str] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        private_ip_address: typing.Optional[builtins.str] = None,
        propagate_tags_to_volume_on_creation: typing.Optional[builtins.bool] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        resource_signal_timeout: typing.Optional[_Duration_4839e8c3] = None,
        role: typing.Optional[_IRole_235f5d8e] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
        source_dest_check: typing.Optional[builtins.bool] = None,
        ssm_session_permissions: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
        user_data_causes_replacement: typing.Optional[builtins.bool] = None,
        vpc_subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Properties of an EC2 Instance.

        :param instance_type: Type of instance to launch.
        :param machine_image: AMI to launch.
        :param vpc: VPC to launch the instance in.
        :param allow_all_ipv6_outbound: Whether the instance could initiate IPv6 connections to anywhere by default. This property is only used when you do not provide a security group. Default: false
        :param allow_all_outbound: Whether the instance could initiate connections to anywhere by default. This property is only used when you do not provide a security group. Default: true
        :param associate_public_ip_address: Whether to associate a public IP address to the primary network interface attached to this instance. Default: - public IP address is automatically assigned based on default behavior
        :param availability_zone: In which AZ to place the instance within the VPC. Default: - Random zone.
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param detailed_monitoring: Whether "Detailed Monitoring" is enabled for this instance Keep in mind that Detailed Monitoring results in extra charges. Default: - false
        :param init: Apply the given CloudFormation Init configuration to the instance at startup. Default: - no CloudFormation init
        :param init_options: Use the given options for applying CloudFormation Init. Describes the configsets to use and the timeout to wait Default: - default options
        :param instance_name: The name of the instance. Default: - CDK generated name
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param private_ip_address: Defines a private IP address to associate with an instance. Private IP should be available within the VPC that the instance is build within. Default: - no association
        :param propagate_tags_to_volume_on_creation: Propagate the EC2 instance tags to the EBS volumes. Default: - false
        :param require_imdsv2: Whether IMDSv2 should be required on this instance. Default: - false
        :param resource_signal_timeout: The length of time to wait for the resourceSignalCount. The maximum value is 43200 (12 hours). Default: Duration.minutes(5)
        :param role: An IAM role to associate with the instance profile assigned to this Auto Scaling Group. The role must be assumable by the service principal ``ec2.amazonaws.com``: Default: - A role will automatically be created, it can be accessed via the ``role`` property
        :param security_group: Security Group to assign to this instance. Default: - create new security group
        :param source_dest_check: Specifies whether to enable an instance launched in a VPC to perform NAT. This controls whether source/destination checking is enabled on the instance. A value of true means that checking is enabled, and false means that checking is disabled. The value must be false for the instance to perform NAT. Default: true
        :param ssm_session_permissions: Add SSM session permissions to the instance role. Setting this to ``true`` adds the necessary permissions to connect to the instance using SSM Session Manager. You can do this from the AWS Console. NOTE: Setting this flag to ``true`` may not be enough by itself. You must also use an AMI that comes with the SSM Agent, or install the SSM Agent yourself. See `Working with SSM Agent <https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html>`_ in the SSM Developer Guide. Default: false
        :param user_data: Specific UserData to use. The UserData may still be mutated after creation. Default: - A UserData object appropriate for the MachineImage's Operating System is created.
        :param user_data_causes_replacement: Changes to the UserData force replacement. Depending the EC2 instance type, changing UserData either restarts the instance or replaces the instance. - Instance store-backed instances are replaced. - EBS-backed instances are restarted. By default, restarting does not execute the new UserData so you will need a different mechanism to ensure the instance is restarted. Setting this to ``true`` will make the instance's Logical ID depend on the UserData, which will cause CloudFormation to replace it if the UserData changes. Default: - true iff ``initOptions`` is specified, false otherwise.
        :param vpc_subnets: Where to place the instance within the VPC. Default: - Private subnets.

        :exampleMetadata: infused

        Example::

            # vpc: ec2.IVpc
            
            lb = elb.LoadBalancer(self, "LB",
                vpc=vpc,
                internet_facing=True
            )
            
            # instance to add as the target for load balancer.
            instance = ec2.Instance(self, "targetInstance",
                vpc=vpc,
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO),
                machine_image=ec2.AmazonLinuxImage(generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2)
            )
            lb.add_target(elb.InstanceTarget(instance))
        '''
        if isinstance(init_options, dict):
            init_options = ApplyCloudFormationInitOptions(**init_options)
        if isinstance(vpc_subnets, dict):
            vpc_subnets = SubnetSelection(**vpc_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d4dc63c6e6ee3ddc68d5dd204d8ac5ef1f1dec37a7b84d636225df1c2f17d22)
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument machine_image", value=machine_image, expected_type=type_hints["machine_image"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument allow_all_ipv6_outbound", value=allow_all_ipv6_outbound, expected_type=type_hints["allow_all_ipv6_outbound"])
            check_type(argname="argument allow_all_outbound", value=allow_all_outbound, expected_type=type_hints["allow_all_outbound"])
            check_type(argname="argument associate_public_ip_address", value=associate_public_ip_address, expected_type=type_hints["associate_public_ip_address"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument block_devices", value=block_devices, expected_type=type_hints["block_devices"])
            check_type(argname="argument detailed_monitoring", value=detailed_monitoring, expected_type=type_hints["detailed_monitoring"])
            check_type(argname="argument init", value=init, expected_type=type_hints["init"])
            check_type(argname="argument init_options", value=init_options, expected_type=type_hints["init_options"])
            check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
            check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
            check_type(argname="argument key_pair", value=key_pair, expected_type=type_hints["key_pair"])
            check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
            check_type(argname="argument propagate_tags_to_volume_on_creation", value=propagate_tags_to_volume_on_creation, expected_type=type_hints["propagate_tags_to_volume_on_creation"])
            check_type(argname="argument require_imdsv2", value=require_imdsv2, expected_type=type_hints["require_imdsv2"])
            check_type(argname="argument resource_signal_timeout", value=resource_signal_timeout, expected_type=type_hints["resource_signal_timeout"])
            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
            check_type(argname="argument source_dest_check", value=source_dest_check, expected_type=type_hints["source_dest_check"])
            check_type(argname="argument ssm_session_permissions", value=ssm_session_permissions, expected_type=type_hints["ssm_session_permissions"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument user_data_causes_replacement", value=user_data_causes_replacement, expected_type=type_hints["user_data_causes_replacement"])
            check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance_type": instance_type,
            "machine_image": machine_image,
            "vpc": vpc,
        }
        if allow_all_ipv6_outbound is not None:
            self._values["allow_all_ipv6_outbound"] = allow_all_ipv6_outbound
        if allow_all_outbound is not None:
            self._values["allow_all_outbound"] = allow_all_outbound
        if associate_public_ip_address is not None:
            self._values["associate_public_ip_address"] = associate_public_ip_address
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if block_devices is not None:
            self._values["block_devices"] = block_devices
        if detailed_monitoring is not None:
            self._values["detailed_monitoring"] = detailed_monitoring
        if init is not None:
            self._values["init"] = init
        if init_options is not None:
            self._values["init_options"] = init_options
        if instance_name is not None:
            self._values["instance_name"] = instance_name
        if key_name is not None:
            self._values["key_name"] = key_name
        if key_pair is not None:
            self._values["key_pair"] = key_pair
        if private_ip_address is not None:
            self._values["private_ip_address"] = private_ip_address
        if propagate_tags_to_volume_on_creation is not None:
            self._values["propagate_tags_to_volume_on_creation"] = propagate_tags_to_volume_on_creation
        if require_imdsv2 is not None:
            self._values["require_imdsv2"] = require_imdsv2
        if resource_signal_timeout is not None:
            self._values["resource_signal_timeout"] = resource_signal_timeout
        if role is not None:
            self._values["role"] = role
        if security_group is not None:
            self._values["security_group"] = security_group
        if source_dest_check is not None:
            self._values["source_dest_check"] = source_dest_check
        if ssm_session_permissions is not None:
            self._values["ssm_session_permissions"] = ssm_session_permissions
        if user_data is not None:
            self._values["user_data"] = user_data
        if user_data_causes_replacement is not None:
            self._values["user_data_causes_replacement"] = user_data_causes_replacement
        if vpc_subnets is not None:
            self._values["vpc_subnets"] = vpc_subnets

    @builtins.property
    def instance_type(self) -> "InstanceType":
        '''Type of instance to launch.'''
        result = self._values.get("instance_type")
        assert result is not None, "Required property 'instance_type' is missing"
        return typing.cast("InstanceType", result)

    @builtins.property
    def machine_image(self) -> IMachineImage:
        '''AMI to launch.'''
        result = self._values.get("machine_image")
        assert result is not None, "Required property 'machine_image' is missing"
        return typing.cast(IMachineImage, result)

    @builtins.property
    def vpc(self) -> IVpc:
        '''VPC to launch the instance in.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast(IVpc, result)

    @builtins.property
    def allow_all_ipv6_outbound(self) -> typing.Optional[builtins.bool]:
        '''Whether the instance could initiate IPv6 connections to anywhere by default.

        This property is only used when you do not provide a security group.

        :default: false
        '''
        result = self._values.get("allow_all_ipv6_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def allow_all_outbound(self) -> typing.Optional[builtins.bool]:
        '''Whether the instance could initiate connections to anywhere by default.

        This property is only used when you do not provide a security group.

        :default: true
        '''
        result = self._values.get("allow_all_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def associate_public_ip_address(self) -> typing.Optional[builtins.bool]:
        '''Whether to associate a public IP address to the primary network interface attached to this instance.

        :default: - public IP address is automatically assigned based on default behavior
        '''
        result = self._values.get("associate_public_ip_address")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''In which AZ to place the instance within the VPC.

        :default: - Random zone.
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def block_devices(self) -> typing.Optional[typing.List[BlockDevice]]:
        '''Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.

        Each instance that is launched has an associated root device volume,
        either an Amazon EBS volume or an instance store volume.
        You can use block device mappings to specify additional EBS volumes or
        instance store volumes to attach to an instance when it is launched.

        :default: - Uses the block device mapping of the AMI

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html
        '''
        result = self._values.get("block_devices")
        return typing.cast(typing.Optional[typing.List[BlockDevice]], result)

    @builtins.property
    def detailed_monitoring(self) -> typing.Optional[builtins.bool]:
        '''Whether "Detailed Monitoring" is enabled for this instance Keep in mind that Detailed Monitoring results in extra charges.

        :default: - false

        :see: http://aws.amazon.com/cloudwatch/pricing/
        '''
        result = self._values.get("detailed_monitoring")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def init(self) -> typing.Optional[CloudFormationInit]:
        '''Apply the given CloudFormation Init configuration to the instance at startup.

        :default: - no CloudFormation init
        '''
        result = self._values.get("init")
        return typing.cast(typing.Optional[CloudFormationInit], result)

    @builtins.property
    def init_options(self) -> typing.Optional[ApplyCloudFormationInitOptions]:
        '''Use the given options for applying CloudFormation Init.

        Describes the configsets to use and the timeout to wait

        :default: - default options
        '''
        result = self._values.get("init_options")
        return typing.cast(typing.Optional[ApplyCloudFormationInitOptions], result)

    @builtins.property
    def instance_name(self) -> typing.Optional[builtins.str]:
        '''The name of the instance.

        :default: - CDK generated name
        '''
        result = self._values.get("instance_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_name(self) -> typing.Optional[builtins.str]:
        '''(deprecated) Name of SSH keypair to grant access to instance.

        :default: - No SSH access will be possible.

        :deprecated: - Use ``keyPair`` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair

        :stability: deprecated
        '''
        result = self._values.get("key_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_pair(self) -> typing.Optional[IKeyPair]:
        '''The SSH keypair to grant access to the instance.

        :default: - No SSH access will be possible.
        '''
        result = self._values.get("key_pair")
        return typing.cast(typing.Optional[IKeyPair], result)

    @builtins.property
    def private_ip_address(self) -> typing.Optional[builtins.str]:
        '''Defines a private IP address to associate with an instance.

        Private IP should be available within the VPC that the instance is build within.

        :default: - no association
        '''
        result = self._values.get("private_ip_address")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def propagate_tags_to_volume_on_creation(self) -> typing.Optional[builtins.bool]:
        '''Propagate the EC2 instance tags to the EBS volumes.

        :default: - false
        '''
        result = self._values.get("propagate_tags_to_volume_on_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def require_imdsv2(self) -> typing.Optional[builtins.bool]:
        '''Whether IMDSv2 should be required on this instance.

        :default: - false
        '''
        result = self._values.get("require_imdsv2")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def resource_signal_timeout(self) -> typing.Optional[_Duration_4839e8c3]:
        '''The length of time to wait for the resourceSignalCount.

        The maximum value is 43200 (12 hours).

        :default: Duration.minutes(5)
        '''
        result = self._values.get("resource_signal_timeout")
        return typing.cast(typing.Optional[_Duration_4839e8c3], result)

    @builtins.property
    def role(self) -> typing.Optional[_IRole_235f5d8e]:
        '''An IAM role to associate with the instance profile assigned to this Auto Scaling Group.

        The role must be assumable by the service principal ``ec2.amazonaws.com``:

        :default: - A role will automatically be created, it can be accessed via the ``role`` property

        Example::

            role = iam.Role(self, "MyRole",
                assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
            )
        '''
        result = self._values.get("role")
        return typing.cast(typing.Optional[_IRole_235f5d8e], result)

    @builtins.property
    def security_group(self) -> typing.Optional[ISecurityGroup]:
        '''Security Group to assign to this instance.

        :default: - create new security group
        '''
        result = self._values.get("security_group")
        return typing.cast(typing.Optional[ISecurityGroup], result)

    @builtins.property
    def source_dest_check(self) -> typing.Optional[builtins.bool]:
        '''Specifies whether to enable an instance launched in a VPC to perform NAT.

        This controls whether source/destination checking is enabled on the instance.
        A value of true means that checking is enabled, and false means that checking is disabled.
        The value must be false for the instance to perform NAT.

        :default: true
        '''
        result = self._values.get("source_dest_check")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ssm_session_permissions(self) -> typing.Optional[builtins.bool]:
        '''Add SSM session permissions to the instance role.

        Setting this to ``true`` adds the necessary permissions to connect
        to the instance using SSM Session Manager. You can do this
        from the AWS Console.

        NOTE: Setting this flag to ``true`` may not be enough by itself.
        You must also use an AMI that comes with the SSM Agent, or install
        the SSM Agent yourself. See
        `Working with SSM Agent <https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html>`_
        in the SSM Developer Guide.

        :default: false
        '''
        result = self._values.get("ssm_session_permissions")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Specific UserData to use.

        The UserData may still be mutated after creation.

        :default:

        - A UserData object appropriate for the MachineImage's
        Operating System is created.
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    @builtins.property
    def user_data_causes_replacement(self) -> typing.Optional[builtins.bool]:
        '''Changes to the UserData force replacement.

        Depending the EC2 instance type, changing UserData either
        restarts the instance or replaces the instance.

        - Instance store-backed instances are replaced.
        - EBS-backed instances are restarted.

        By default, restarting does not execute the new UserData so you
        will need a different mechanism to ensure the instance is restarted.

        Setting this to ``true`` will make the instance's Logical ID depend on the
        UserData, which will cause CloudFormation to replace it if the UserData
        changes.

        :default: - true iff ``initOptions`` is specified, false otherwise.
        '''
        result = self._values.get("user_data_causes_replacement")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def vpc_subnets(self) -> typing.Optional["SubnetSelection"]:
        '''Where to place the instance within the VPC.

        :default: - Private subnets.
        '''
        result = self._values.get("vpc_subnets")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InstanceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IAspect_118c810a)
class InstanceRequireImdsv2Aspect(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InstanceRequireImdsv2Aspect",
):
    '''Aspect that applies IMDS configuration on EC2 Instance constructs.

    This aspect configures IMDS on an EC2 instance by creating a Launch Template with the
    IMDS configuration and associating that Launch Template with the instance. If an Instance
    is already associated with a Launch Template, a warning will (optionally) be added to the
    construct node and it will be skipped.

    To cover Instances already associated with Launch Templates, use ``LaunchTemplateImdsAspect``.

    :exampleMetadata: infused

    Example::

        aspect = ec2.InstanceRequireImdsv2Aspect()
        Aspects.of(self).add(aspect)
    '''

    def __init__(
        self,
        *,
        suppress_launch_template_warning: typing.Optional[builtins.bool] = None,
        suppress_warnings: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param suppress_launch_template_warning: Whether warnings that would be raised when an Instance is associated with an existing Launch Template should be suppressed or not. You can set this to ``true`` if ``LaunchTemplateImdsAspect`` is being used alongside this Aspect to suppress false-positive warnings because any Launch Templates associated with Instances will still be covered. Default: - false
        :param suppress_warnings: Whether warning annotations from this Aspect should be suppressed or not. Default: - false
        '''
        props = InstanceRequireImdsv2AspectProps(
            suppress_launch_template_warning=suppress_launch_template_warning,
            suppress_warnings=suppress_warnings,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''All aspects can visit an IConstruct.

        :param node: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ea080e9a48a9cd3f51ab887978d6f84898a3e75d15344d8c22ea42bcbad6fc8e)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast(None, jsii.invoke(self, "visit", [node]))

    @jsii.member(jsii_name="warn")
    def _warn(
        self,
        node: _constructs_77d1e7e8.IConstruct,
        message: builtins.str,
    ) -> None:
        '''Adds a warning annotation to a node, unless ``suppressWarnings`` is true.

        :param node: -
        :param message: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4774943551492528ef831ac6f6b59622fcebed6ac26f559cada819b1ecb0de66)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
        return typing.cast(None, jsii.invoke(self, "warn", [node, message]))

    @builtins.property
    @jsii.member(jsii_name="suppressWarnings")
    def _suppress_warnings(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "suppressWarnings"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InstanceRequireImdsv2AspectProps",
    jsii_struct_bases=[],
    name_mapping={
        "suppress_launch_template_warning": "suppressLaunchTemplateWarning",
        "suppress_warnings": "suppressWarnings",
    },
)
class InstanceRequireImdsv2AspectProps:
    def __init__(
        self,
        *,
        suppress_launch_template_warning: typing.Optional[builtins.bool] = None,
        suppress_warnings: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Properties for ``InstanceRequireImdsv2Aspect``.

        :param suppress_launch_template_warning: Whether warnings that would be raised when an Instance is associated with an existing Launch Template should be suppressed or not. You can set this to ``true`` if ``LaunchTemplateImdsAspect`` is being used alongside this Aspect to suppress false-positive warnings because any Launch Templates associated with Instances will still be covered. Default: - false
        :param suppress_warnings: Whether warning annotations from this Aspect should be suppressed or not. Default: - false

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            instance_require_imdsv2_aspect_props = ec2.InstanceRequireImdsv2AspectProps(
                suppress_launch_template_warning=False,
                suppress_warnings=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9326e8778e870d6503548ff3c5ed500440af6b908992d24dc8f76fa89771555)
            check_type(argname="argument suppress_launch_template_warning", value=suppress_launch_template_warning, expected_type=type_hints["suppress_launch_template_warning"])
            check_type(argname="argument suppress_warnings", value=suppress_warnings, expected_type=type_hints["suppress_warnings"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if suppress_launch_template_warning is not None:
            self._values["suppress_launch_template_warning"] = suppress_launch_template_warning
        if suppress_warnings is not None:
            self._values["suppress_warnings"] = suppress_warnings

    @builtins.property
    def suppress_launch_template_warning(self) -> typing.Optional[builtins.bool]:
        '''Whether warnings that would be raised when an Instance is associated with an existing Launch Template should be suppressed or not.

        You can set this to ``true`` if ``LaunchTemplateImdsAspect`` is being used alongside this Aspect to
        suppress false-positive warnings because any Launch Templates associated with Instances will still be covered.

        :default: - false
        '''
        result = self._values.get("suppress_launch_template_warning")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def suppress_warnings(self) -> typing.Optional[builtins.bool]:
        '''Whether warning annotations from this Aspect should be suppressed or not.

        :default: - false
        '''
        result = self._values.get("suppress_warnings")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InstanceRequireImdsv2AspectProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.InstanceSize")
class InstanceSize(enum.Enum):
    '''What size of instance to use.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        cluster = rds.DatabaseCluster(self, "Database",
            engine=rds.DatabaseClusterEngine.aurora_mysql(version=rds.AuroraMysqlEngineVersion.VER_3_01_0),
            writer=rds.ClusterInstance.provisioned("writer",
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.R6G, ec2.InstanceSize.XLARGE4)
            ),
            serverless_v2_min_capacity=6.5,
            serverless_v2_max_capacity=64,
            readers=[
                # will be put in promotion tier 1 and will scale with the writer
                rds.ClusterInstance.serverless_v2("reader1", scale_with_writer=True),
                # will be put in promotion tier 2 and will not scale with the writer
                rds.ClusterInstance.serverless_v2("reader2")
            ],
            vpc=vpc
        )
    '''

    NANO = "NANO"
    '''Instance size NANO (nano).'''
    MICRO = "MICRO"
    '''Instance size MICRO (micro).'''
    SMALL = "SMALL"
    '''Instance size SMALL (small).'''
    MEDIUM = "MEDIUM"
    '''Instance size MEDIUM (medium).'''
    LARGE = "LARGE"
    '''Instance size LARGE (large).'''
    XLARGE = "XLARGE"
    '''Instance size XLARGE (xlarge).'''
    XLARGE2 = "XLARGE2"
    '''Instance size XLARGE2 (2xlarge).'''
    XLARGE3 = "XLARGE3"
    '''Instance size XLARGE3 (3xlarge).'''
    XLARGE4 = "XLARGE4"
    '''Instance size XLARGE4 (4xlarge).'''
    XLARGE6 = "XLARGE6"
    '''Instance size XLARGE6 (6xlarge).'''
    XLARGE8 = "XLARGE8"
    '''Instance size XLARGE8 (8xlarge).'''
    XLARGE9 = "XLARGE9"
    '''Instance size XLARGE9 (9xlarge).'''
    XLARGE10 = "XLARGE10"
    '''Instance size XLARGE10 (10xlarge).'''
    XLARGE12 = "XLARGE12"
    '''Instance size XLARGE12 (12xlarge).'''
    XLARGE16 = "XLARGE16"
    '''Instance size XLARGE16 (16xlarge).'''
    XLARGE18 = "XLARGE18"
    '''Instance size XLARGE18 (18xlarge).'''
    XLARGE24 = "XLARGE24"
    '''Instance size XLARGE24 (24xlarge).'''
    XLARGE32 = "XLARGE32"
    '''Instance size XLARGE32 (32xlarge).'''
    XLARGE48 = "XLARGE48"
    '''Instance size XLARGE48 (48xlarge).'''
    XLARGE56 = "XLARGE56"
    '''Instance size XLARGE56 (56xlarge).'''
    XLARGE112 = "XLARGE112"
    '''Instance size XLARGE56 (112xlarge).'''
    METAL = "METAL"
    '''Instance size METAL (metal).'''


class InstanceType(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InstanceType",
):
    '''Instance type for EC2 instances.

    This class takes a literal string, good if you already
    know the identifier of the type you want.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        cluster = docdb.DatabaseCluster(self, "Database",
            master_user=docdb.Login(
                username="myuser",  # NOTE: 'admin' is reserved by DocumentDB
                exclude_characters="\"@/:",  # optional, defaults to the set "\"@/" and is also used for eventually created rotations
                secret_name="/myapp/mydocdb/masteruser"
            ),
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.MEMORY5, ec2.InstanceSize.LARGE),
            vpc_subnets=ec2.SubnetSelection(
                subnet_type=ec2.SubnetType.PUBLIC
            ),
            vpc=vpc
        )
    '''

    def __init__(self, instance_type_identifier: builtins.str) -> None:
        '''
        :param instance_type_identifier: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f9e12e553c32475e068e0d7318afcf27197468eae438a6b5020d7d6a0231705f)
            check_type(argname="argument instance_type_identifier", value=instance_type_identifier, expected_type=type_hints["instance_type_identifier"])
        jsii.create(self.__class__, self, [instance_type_identifier])

    @jsii.member(jsii_name="of")
    @builtins.classmethod
    def of(
        cls,
        instance_class: InstanceClass,
        instance_size: InstanceSize,
    ) -> "InstanceType":
        '''Instance type for EC2 instances.

        This class takes a combination of a class and size.

        Be aware that not all combinations of class and size are available, and not all
        classes are available in all regions.

        :param instance_class: -
        :param instance_size: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__97857b0f234071f13c18c9a44e7361ba42c63c7f58a30dde519a60f470c51b66)
            check_type(argname="argument instance_class", value=instance_class, expected_type=type_hints["instance_class"])
            check_type(argname="argument instance_size", value=instance_size, expected_type=type_hints["instance_size"])
        return typing.cast("InstanceType", jsii.sinvoke(cls, "of", [instance_class, instance_size]))

    @jsii.member(jsii_name="sameInstanceClassAs")
    def same_instance_class_as(self, other: "InstanceType") -> builtins.bool:
        '''
        :param other: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__88f762204486759e1d4b8675273e25b3521a634edd036f75323d5584453cccf1)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
        return typing.cast(builtins.bool, jsii.invoke(self, "sameInstanceClassAs", [other]))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        '''Return the instance type as a dotted string.'''
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="architecture")
    def architecture(self) -> InstanceArchitecture:
        '''The instance's CPU architecture.'''
        return typing.cast(InstanceArchitecture, jsii.get(self, "architecture"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpointAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "port": "port",
        "vpc_endpoint_id": "vpcEndpointId",
        "security_groups": "securityGroups",
    },
)
class InterfaceVpcEndpointAttributes:
    def __init__(
        self,
        *,
        port: jsii.Number,
        vpc_endpoint_id: builtins.str,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    ) -> None:
        '''Construction properties for an ImportedInterfaceVpcEndpoint.

        :param port: The port of the service of the interface VPC endpoint.
        :param vpc_endpoint_id: The interface VPC endpoint identifier.
        :param security_groups: The security groups associated with the interface VPC endpoint. If you wish to manage the network connections associated with this endpoint, you will need to specify its security groups.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # security_group: ec2.SecurityGroup
            
            interface_vpc_endpoint_attributes = ec2.InterfaceVpcEndpointAttributes(
                port=123,
                vpc_endpoint_id="vpcEndpointId",
            
                # the properties below are optional
                security_groups=[security_group]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__67e7c8a745d0e9f6bf5d01dd69a00a15a09e2b5a0246690fad6ba8759c33a0e4)
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
            check_type(argname="argument vpc_endpoint_id", value=vpc_endpoint_id, expected_type=type_hints["vpc_endpoint_id"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "port": port,
            "vpc_endpoint_id": vpc_endpoint_id,
        }
        if security_groups is not None:
            self._values["security_groups"] = security_groups

    @builtins.property
    def port(self) -> jsii.Number:
        '''The port of the service of the interface VPC endpoint.'''
        result = self._values.get("port")
        assert result is not None, "Required property 'port' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def vpc_endpoint_id(self) -> builtins.str:
        '''The interface VPC endpoint identifier.'''
        result = self._values.get("vpc_endpoint_id")
        assert result is not None, "Required property 'vpc_endpoint_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List[ISecurityGroup]]:
        '''The security groups associated with the interface VPC endpoint.

        If you wish to manage the network connections associated with this endpoint,
        you will need to specify its security groups.
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[ISecurityGroup]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InterfaceVpcEndpointAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IInterfaceVpcEndpointService)
class InterfaceVpcEndpointAwsService(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpointAwsService",
):
    '''An AWS service for an interface VPC endpoint.

    :exampleMetadata: lit=aws-ec2/test/integ.vpc-endpoint.lit.ts infused

    Example::

        # Add gateway endpoints when creating the VPC
        vpc = ec2.Vpc(self, "MyVpc",
            gateway_endpoints={
                "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
                    service=ec2.GatewayVpcEndpointAwsService.S3
                )
            }
        )
        
        # Alternatively gateway endpoints can be added on the VPC
        dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
            service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
        )
        
        # This allows to customize the endpoint policy
        dynamo_db_endpoint.add_to_policy(
            iam.PolicyStatement( # Restrict to listing and describing tables
                principals=[iam.AnyPrincipal()],
                actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
                resources=["*"]))
        
        # Add an interface endpoint
        vpc.add_interface_endpoint("EcrDockerEndpoint",
            service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
        )
    '''

    def __init__(
        self,
        name: builtins.str,
        prefix: typing.Optional[builtins.str] = None,
        port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param name: The name of the service.
        :param prefix: -
        :param port: The port of the service.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3c5ecdce361b18ac8c903c131db56fe0de6c60b272b32768f92c0f0eaf6cccde)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        jsii.create(self.__class__, self, [name, prefix, port])

    @jsii.python.classproperty
    @jsii.member(jsii_name="ACCESS_ANALYZER")
    def ACCESS_ANALYZER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ACCESS_ANALYZER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ACCOUNT_MANAGEMENT")
    def ACCOUNT_MANAGEMENT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ACCOUNT_MANAGEMENT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AIRFLOW_API")
    def AIRFLOW_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AIRFLOW_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AIRFLOW_ENV")
    def AIRFLOW_ENV(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AIRFLOW_ENV"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AIRFLOW_OPS")
    def AIRFLOW_OPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AIRFLOW_OPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APIGATEWAY")
    def APIGATEWAY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APIGATEWAY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APP_MESH")
    def APP_MESH(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APP_MESH"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APP_RUNNER")
    def APP_RUNNER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APP_RUNNER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APP_RUNNER_REQUESTS")
    def APP_RUNNER_REQUESTS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APP_RUNNER_REQUESTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APP_SYNC")
    def APP_SYNC(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APP_SYNC"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APPLICATION_AUTOSCALING")
    def APPLICATION_AUTOSCALING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APPLICATION_AUTOSCALING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APPLICATION_MIGRATION_SERVICE")
    def APPLICATION_MIGRATION_SERVICE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APPLICATION_MIGRATION_SERVICE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APPSTREAM_API")
    def APPSTREAM_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APPSTREAM_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="APPSTREAM_STREAMING")
    def APPSTREAM_STREAMING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "APPSTREAM_STREAMING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ATHENA")
    def ATHENA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ATHENA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AUDIT_MANAGER")
    def AUDIT_MANAGER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AUDIT_MANAGER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AUTOSCALING")
    def AUTOSCALING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AUTOSCALING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AUTOSCALING_PLANS")
    def AUTOSCALING_PLANS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "AUTOSCALING_PLANS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BACKUP")
    def BACKUP(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "BACKUP"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BACKUP_GATEWAY")
    def BACKUP_GATEWAY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "BACKUP_GATEWAY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BATCH")
    def BATCH(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "BATCH"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BILLING_CONDUCTOR")
    def BILLING_CONDUCTOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "BILLING_CONDUCTOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BRAKET")
    def BRAKET(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "BRAKET"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUD_CONTROL_API")
    def CLOUD_CONTROL_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUD_CONTROL_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUD_CONTROL_API_FIPS")
    def CLOUD_CONTROL_API_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUD_CONTROL_API_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUD_DIRECTORY")
    def CLOUD_DIRECTORY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUD_DIRECTORY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDFORMATION")
    def CLOUDFORMATION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDFORMATION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDHSM")
    def CLOUDHSM(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDHSM"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDTRAIL")
    def CLOUDTRAIL(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDTRAIL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH")
    def CLOUDWATCH(cls) -> "InterfaceVpcEndpointAwsService":
        '''
        :deprecated: - Use InterfaceVpcEndpointAwsService.CLOUDWATCH_MONITORING instead.

        :stability: deprecated
        '''
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_EVENTS")
    def CLOUDWATCH_EVENTS(cls) -> "InterfaceVpcEndpointAwsService":
        '''
        :deprecated: - Use InterfaceVpcEndpointAwsService.EVENTBRIDGE instead.

        :stability: deprecated
        '''
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_EVENTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_EVIDENTLY")
    def CLOUDWATCH_EVIDENTLY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_EVIDENTLY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_EVIDENTLY_DATAPLANE")
    def CLOUDWATCH_EVIDENTLY_DATAPLANE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_EVIDENTLY_DATAPLANE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_LOGS")
    def CLOUDWATCH_LOGS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_LOGS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_MONITORING")
    def CLOUDWATCH_MONITORING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_MONITORING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_RUM")
    def CLOUDWATCH_RUM(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_RUM"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_RUM_DATAPLANE")
    def CLOUDWATCH_RUM_DATAPLANE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_RUM_DATAPLANE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUDWATCH_SYNTHETICS")
    def CLOUDWATCH_SYNTHETICS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CLOUDWATCH_SYNTHETICS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEARTIFACT_API")
    def CODEARTIFACT_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEARTIFACT_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEARTIFACT_REPOSITORIES")
    def CODEARTIFACT_REPOSITORIES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEARTIFACT_REPOSITORIES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEBUILD")
    def CODEBUILD(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEBUILD"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEBUILD_FIPS")
    def CODEBUILD_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEBUILD_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODECOMMIT")
    def CODECOMMIT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODECOMMIT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODECOMMIT_FIPS")
    def CODECOMMIT_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODECOMMIT_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODECOMMIT_GIT")
    def CODECOMMIT_GIT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODECOMMIT_GIT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODECOMMIT_GIT_FIPS")
    def CODECOMMIT_GIT_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODECOMMIT_GIT_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEDEPLOY")
    def CODEDEPLOY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEDEPLOY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEDEPLOY_COMMANDS_SECURE")
    def CODEDEPLOY_COMMANDS_SECURE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEDEPLOY_COMMANDS_SECURE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEGURU_PROFILER")
    def CODEGURU_PROFILER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEGURU_PROFILER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEGURU_REVIEWER")
    def CODEGURU_REVIEWER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEGURU_REVIEWER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODEPIPELINE")
    def CODEPIPELINE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODEPIPELINE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CODESTAR_CONNECTIONS")
    def CODESTAR_CONNECTIONS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CODESTAR_CONNECTIONS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="COMPREHEND")
    def COMPREHEND(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "COMPREHEND"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="COMPREHEND_MEDICAL")
    def COMPREHEND_MEDICAL(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "COMPREHEND_MEDICAL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONFIG")
    def CONFIG(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONFIG"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_APP_INTEGRATIONS")
    def CONNECT_APP_INTEGRATIONS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_APP_INTEGRATIONS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_CASES")
    def CONNECT_CASES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_CASES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_CONNECT_CAMPAIGNS")
    def CONNECT_CONNECT_CAMPAIGNS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_CONNECT_CAMPAIGNS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_PROFILE")
    def CONNECT_PROFILE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_PROFILE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_VOICEID")
    def CONNECT_VOICEID(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_VOICEID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="CONNECT_WISDOM")
    def CONNECT_WISDOM(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "CONNECT_WISDOM"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DATA_EXCHANGE")
    def DATA_EXCHANGE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DATA_EXCHANGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DATABASE_MIGRATION_SERVICE")
    def DATABASE_MIGRATION_SERVICE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DATABASE_MIGRATION_SERVICE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DATABASE_MIGRATION_SERVICE_FIPS")
    def DATABASE_MIGRATION_SERVICE_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DATABASE_MIGRATION_SERVICE_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DATASYNC")
    def DATASYNC(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DATASYNC"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEVOPS_GURU")
    def DEVOPS_GURU(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DEVOPS_GURU"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EBS_DIRECT")
    def EBS_DIRECT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EBS_DIRECT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EC2")
    def EC2(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EC2"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EC2_MESSAGES")
    def EC2_MESSAGES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EC2_MESSAGES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ECR")
    def ECR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ECR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ECR_DOCKER")
    def ECR_DOCKER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ECR_DOCKER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ECS")
    def ECS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ECS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ECS_AGENT")
    def ECS_AGENT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ECS_AGENT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ECS_TELEMETRY")
    def ECS_TELEMETRY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ECS_TELEMETRY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EKS")
    def EKS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EKS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_BEANSTALK")
    def ELASTIC_BEANSTALK(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_BEANSTALK"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_BEANSTALK_HEALTH")
    def ELASTIC_BEANSTALK_HEALTH(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_BEANSTALK_HEALTH"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_DISASTER_RECOVERY")
    def ELASTIC_DISASTER_RECOVERY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_DISASTER_RECOVERY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_FILESYSTEM")
    def ELASTIC_FILESYSTEM(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_FILESYSTEM"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_FILESYSTEM_FIPS")
    def ELASTIC_FILESYSTEM_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_FILESYSTEM_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_INFERENCE_RUNTIME")
    def ELASTIC_INFERENCE_RUNTIME(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_INFERENCE_RUNTIME"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTIC_LOAD_BALANCING")
    def ELASTIC_LOAD_BALANCING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTIC_LOAD_BALANCING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTICACHE")
    def ELASTICACHE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTICACHE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ELASTICACHE_FIPS")
    def ELASTICACHE_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ELASTICACHE_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EMAIL_SMTP")
    def EMAIL_SMTP(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EMAIL_SMTP"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EMR")
    def EMR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EMR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EMR_EKS")
    def EMR_EKS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EMR_EKS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EMR_SERVERLESS")
    def EMR_SERVERLESS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EMR_SERVERLESS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="EVENTBRIDGE")
    def EVENTBRIDGE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "EVENTBRIDGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FAULT_INJECTION_SIMULATOR")
    def FAULT_INJECTION_SIMULATOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FAULT_INJECTION_SIMULATOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FINSPACE")
    def FINSPACE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FINSPACE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FINSPACE_API")
    def FINSPACE_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FINSPACE_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FORECAST")
    def FORECAST(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FORECAST"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FORECAST_FIPS")
    def FORECAST_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FORECAST_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FORECAST_QUERY")
    def FORECAST_QUERY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FORECAST_QUERY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FORECAST_QUERY_FIPS")
    def FORECAST_QUERY_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FORECAST_QUERY_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FRAUD_DETECTOR")
    def FRAUD_DETECTOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FRAUD_DETECTOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FSX")
    def FSX(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FSX"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FSX_FIPS")
    def FSX_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "FSX_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GLUE")
    def GLUE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "GLUE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GLUE_DATABREW")
    def GLUE_DATABREW(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "GLUE_DATABREW"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GRAFANA")
    def GRAFANA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "GRAFANA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GRAFANA_WORKSPACE")
    def GRAFANA_WORKSPACE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "GRAFANA_WORKSPACE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GROUNDSTATION")
    def GROUNDSTATION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "GROUNDSTATION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="HEALTHLAKE")
    def HEALTHLAKE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "HEALTHLAKE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IAM_IDENTITY_CENTER")
    def IAM_IDENTITY_CENTER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IAM_IDENTITY_CENTER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IAM_ROLES_ANYWHERE")
    def IAM_ROLES_ANYWHERE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IAM_ROLES_ANYWHERE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IMAGE_BUILDER")
    def IMAGE_BUILDER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IMAGE_BUILDER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="INSPECTOR")
    def INSPECTOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "INSPECTOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_CORE")
    def IOT_CORE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_CORE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_CORE_DEVICE_ADVISOR")
    def IOT_CORE_DEVICE_ADVISOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_CORE_DEVICE_ADVISOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_CORE_FOR_LORAWAN")
    def IOT_CORE_FOR_LORAWAN(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_CORE_FOR_LORAWAN"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_GREENGRASS")
    def IOT_GREENGRASS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_GREENGRASS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_LORAWAN_CUPS")
    def IOT_LORAWAN_CUPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_LORAWAN_CUPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_LORAWAN_LNS")
    def IOT_LORAWAN_LNS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_LORAWAN_LNS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_ROBORUNNER")
    def IOT_ROBORUNNER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_ROBORUNNER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_SITEWISE_API")
    def IOT_SITEWISE_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_SITEWISE_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_SITEWISE_DATA")
    def IOT_SITEWISE_DATA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_SITEWISE_DATA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_TWINMAKER_API")
    def IOT_TWINMAKER_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_TWINMAKER_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="IOT_TWINMAKER_DATA")
    def IOT_TWINMAKER_DATA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "IOT_TWINMAKER_DATA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KENDRA")
    def KENDRA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KENDRA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KENDRA_RANKING")
    def KENDRA_RANKING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KENDRA_RANKING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KEYSPACES")
    def KEYSPACES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KEYSPACES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KEYSPACES_FIPS")
    def KEYSPACES_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KEYSPACES_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KINESIS_FIREHOSE")
    def KINESIS_FIREHOSE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KINESIS_FIREHOSE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KINESIS_STREAMS")
    def KINESIS_STREAMS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KINESIS_STREAMS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KMS")
    def KMS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KMS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="KMS_FIPS")
    def KMS_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "KMS_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LAKE_FORMATION")
    def LAKE_FORMATION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LAKE_FORMATION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LAMBDA")
    def LAMBDA_(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LAMBDA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LEX_MODELS")
    def LEX_MODELS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LEX_MODELS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LEX_RUNTIME")
    def LEX_RUNTIME(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LEX_RUNTIME"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LICENSE_MANAGER")
    def LICENSE_MANAGER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LICENSE_MANAGER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LICENSE_MANAGER_FIPS")
    def LICENSE_MANAGER_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LICENSE_MANAGER_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LOOKOUT_EQUIPMENT")
    def LOOKOUT_EQUIPMENT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LOOKOUT_EQUIPMENT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LOOKOUT_METRICS")
    def LOOKOUT_METRICS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LOOKOUT_METRICS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LOOKOUT_VISION")
    def LOOKOUT_VISION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "LOOKOUT_VISION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MACIE")
    def MACIE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MACIE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MAINFRAME_MODERNIZATION")
    def MAINFRAME_MODERNIZATION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MAINFRAME_MODERNIZATION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MEMORY_DB")
    def MEMORY_DB(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MEMORY_DB"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MEMORY_DB_FIPS")
    def MEMORY_DB_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MEMORY_DB_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MIGRATIONHUB_ORCHESTRATOR")
    def MIGRATIONHUB_ORCHESTRATOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MIGRATIONHUB_ORCHESTRATOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MIGRATIONHUB_REFACTOR_SPACES")
    def MIGRATIONHUB_REFACTOR_SPACES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MIGRATIONHUB_REFACTOR_SPACES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MIGRATIONHUB_STRATEGY")
    def MIGRATIONHUB_STRATEGY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "MIGRATIONHUB_STRATEGY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="NIMBLE_STUDIO")
    def NIMBLE_STUDIO(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "NIMBLE_STUDIO"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OMICS_ANALYTICS")
    def OMICS_ANALYTICS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "OMICS_ANALYTICS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OMICS_CONTROL_STORAGE")
    def OMICS_CONTROL_STORAGE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "OMICS_CONTROL_STORAGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OMICS_STORAGE")
    def OMICS_STORAGE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "OMICS_STORAGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OMICS_TAGS")
    def OMICS_TAGS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "OMICS_TAGS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OMICS_WORKFLOWS")
    def OMICS_WORKFLOWS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "OMICS_WORKFLOWS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PANORAMA")
    def PANORAMA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PANORAMA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PINPOINT")
    def PINPOINT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PINPOINT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="POLLY")
    def POLLY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "POLLY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PRIVATE_5G")
    def PRIVATE_5_G(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PRIVATE_5G"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PRIVATE_CERTIFICATE_AUTHORITY")
    def PRIVATE_CERTIFICATE_AUTHORITY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PRIVATE_CERTIFICATE_AUTHORITY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROMETHEUS")
    def PROMETHEUS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PROMETHEUS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROMETHEUS_WORKSPACES")
    def PROMETHEUS_WORKSPACES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PROMETHEUS_WORKSPACES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROTON")
    def PROTON(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "PROTON"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="QLDB")
    def QLDB(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "QLDB"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="RDS")
    def RDS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "RDS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="RDS_DATA")
    def RDS_DATA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "RDS_DATA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDSHIFT")
    def REDSHIFT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "REDSHIFT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDSHIFT_DATA")
    def REDSHIFT_DATA(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "REDSHIFT_DATA"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REDSHIFT_FIPS")
    def REDSHIFT_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "REDSHIFT_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REKOGNITION")
    def REKOGNITION(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "REKOGNITION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REKOGNITION_FIPS")
    def REKOGNITION_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "REKOGNITION_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ROBOMAKER")
    def ROBOMAKER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "ROBOMAKER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="S3")
    def S3(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "S3"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="S3_MULTI_REGION_ACCESS_POINTS")
    def S3_MULTI_REGION_ACCESS_POINTS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "S3_MULTI_REGION_ACCESS_POINTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="S3_OUTPOSTS")
    def S3_OUTPOSTS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "S3_OUTPOSTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_API")
    def SAGEMAKER_API(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_API"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_FEATURESTORE_RUNTIME")
    def SAGEMAKER_FEATURESTORE_RUNTIME(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_FEATURESTORE_RUNTIME"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_METRICS")
    def SAGEMAKER_METRICS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_METRICS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_NOTEBOOK")
    def SAGEMAKER_NOTEBOOK(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_NOTEBOOK"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_RUNTIME")
    def SAGEMAKER_RUNTIME(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_RUNTIME"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_RUNTIME_FIPS")
    def SAGEMAKER_RUNTIME_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_RUNTIME_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SAGEMAKER_STUDIO")
    def SAGEMAKER_STUDIO(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SAGEMAKER_STUDIO"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SECRETS_MANAGER")
    def SECRETS_MANAGER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SECRETS_MANAGER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SECURITYHUB")
    def SECURITYHUB(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SECURITYHUB"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SERVER_MIGRATION_SERVICE")
    def SERVER_MIGRATION_SERVICE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SERVER_MIGRATION_SERVICE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SERVER_MIGRATION_SERVICE_AWSCONNECTOR")
    def SERVER_MIGRATION_SERVICE_AWSCONNECTOR(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SERVER_MIGRATION_SERVICE_AWSCONNECTOR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SERVER_MIGRATION_SERVICE_FIPS")
    def SERVER_MIGRATION_SERVICE_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SERVER_MIGRATION_SERVICE_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SERVICE_CATALOG")
    def SERVICE_CATALOG(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SERVICE_CATALOG"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SERVICE_CATALOG_APPREGISTRY")
    def SERVICE_CATALOG_APPREGISTRY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SERVICE_CATALOG_APPREGISTRY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SES")
    def SES(cls) -> "InterfaceVpcEndpointAwsService":
        '''
        :deprecated: - Use InterfaceVpcEndpointAwsService.EMAIL_SMTP instead.

        :stability: deprecated
        '''
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SNOW_DEVICE_MANAGEMENT")
    def SNOW_DEVICE_MANAGEMENT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SNOW_DEVICE_MANAGEMENT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SNS")
    def SNS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SNS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SQS")
    def SQS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SQS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SSM")
    def SSM(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SSM"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SSM_CONTACTS")
    def SSM_CONTACTS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SSM_CONTACTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SSM_INCIDENTS")
    def SSM_INCIDENTS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SSM_INCIDENTS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SSM_MESSAGES")
    def SSM_MESSAGES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SSM_MESSAGES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STEP_FUNCTIONS")
    def STEP_FUNCTIONS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STEP_FUNCTIONS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STEP_FUNCTIONS_SYNC")
    def STEP_FUNCTIONS_SYNC(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STEP_FUNCTIONS_SYNC"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STORAGE_GATEWAY")
    def STORAGE_GATEWAY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STORAGE_GATEWAY"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="STS")
    def STS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TEXTRACT")
    def TEXTRACT(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TEXTRACT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TEXTRACT_FIPS")
    def TEXTRACT_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TEXTRACT_FIPS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRANSCRIBE")
    def TRANSCRIBE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TRANSCRIBE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRANSCRIBE_STREAMING")
    def TRANSCRIBE_STREAMING(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TRANSCRIBE_STREAMING"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRANSFER")
    def TRANSFER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TRANSFER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRANSFER_SERVER")
    def TRANSFER_SERVER(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TRANSFER_SERVER"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRANSLATE")
    def TRANSLATE(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "TRANSLATE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="VERIFIED_PERMISSIONS")
    def VERIFIED_PERMISSIONS(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "VERIFIED_PERMISSIONS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WORKSPACES")
    def WORKSPACES(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "WORKSPACES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="XRAY")
    def XRAY(cls) -> "InterfaceVpcEndpointAwsService":
        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "XRAY"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.

        e.g. com.amazonaws.us-east-1.ecs
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="port")
    def port(self) -> jsii.Number:
        '''The port of the service.'''
        return typing.cast(jsii.Number, jsii.get(self, "port"))

    @builtins.property
    @jsii.member(jsii_name="shortName")
    def short_name(self) -> builtins.str:
        '''The short name of the service.

        e.g. ecs
        '''
        return typing.cast(builtins.str, jsii.get(self, "shortName"))

    @builtins.property
    @jsii.member(jsii_name="privateDnsDefault")
    def private_dns_default(self) -> typing.Optional[builtins.bool]:
        '''Whether Private DNS is supported by default.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "privateDnsDefault"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpointOptions",
    jsii_struct_bases=[],
    name_mapping={
        "service": "service",
        "lookup_supported_azs": "lookupSupportedAzs",
        "open": "open",
        "private_dns_enabled": "privateDnsEnabled",
        "security_groups": "securityGroups",
        "subnets": "subnets",
    },
)
class InterfaceVpcEndpointOptions:
    def __init__(
        self,
        *,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Options to add an interface endpoint to a VPC.

        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets

        :exampleMetadata: lit=aws-ec2/test/integ.vpc-endpoint.lit.ts infused

        Example::

            # Add gateway endpoints when creating the VPC
            vpc = ec2.Vpc(self, "MyVpc",
                gateway_endpoints={
                    "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
                        service=ec2.GatewayVpcEndpointAwsService.S3
                    )
                }
            )
            
            # Alternatively gateway endpoints can be added on the VPC
            dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
                service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
            )
            
            # This allows to customize the endpoint policy
            dynamo_db_endpoint.add_to_policy(
                iam.PolicyStatement( # Restrict to listing and describing tables
                    principals=[iam.AnyPrincipal()],
                    actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
                    resources=["*"]))
            
            # Add an interface endpoint
            vpc.add_interface_endpoint("EcrDockerEndpoint",
                service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
            )
        '''
        if isinstance(subnets, dict):
            subnets = SubnetSelection(**subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a6dd0208e338cbe286ecaa3bcf5f95a5f0a0c1e1b3565ca6de058b5fbe2bbdf)
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
            check_type(argname="argument lookup_supported_azs", value=lookup_supported_azs, expected_type=type_hints["lookup_supported_azs"])
            check_type(argname="argument open", value=open, expected_type=type_hints["open"])
            check_type(argname="argument private_dns_enabled", value=private_dns_enabled, expected_type=type_hints["private_dns_enabled"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service": service,
        }
        if lookup_supported_azs is not None:
            self._values["lookup_supported_azs"] = lookup_supported_azs
        if open is not None:
            self._values["open"] = open
        if private_dns_enabled is not None:
            self._values["private_dns_enabled"] = private_dns_enabled
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if subnets is not None:
            self._values["subnets"] = subnets

    @builtins.property
    def service(self) -> IInterfaceVpcEndpointService:
        '''The service to use for this interface VPC endpoint.'''
        result = self._values.get("service")
        assert result is not None, "Required property 'service' is missing"
        return typing.cast(IInterfaceVpcEndpointService, result)

    @builtins.property
    def lookup_supported_azs(self) -> typing.Optional[builtins.bool]:
        '''Limit to only those availability zones where the endpoint service can be created.

        Setting this to 'true' requires a lookup to be performed at synthesis time. Account
        and region must be set on the containing stack for this to work.

        :default: false
        '''
        result = self._values.get("lookup_supported_azs")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def open(self) -> typing.Optional[builtins.bool]:
        '''Whether to automatically allow VPC traffic to the endpoint.

        If enabled, all traffic to the endpoint from within the VPC will be
        automatically allowed. This is done based on the VPC's CIDR range.

        :default: true
        '''
        result = self._values.get("open")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def private_dns_enabled(self) -> typing.Optional[builtins.bool]:
        '''Whether to associate a private hosted zone with the specified VPC.

        This
        allows you to make requests to the service using its default DNS hostname.

        :default:

        set by the instance of IInterfaceVpcEndpointService, or true if
        not defined by the instance of IInterfaceVpcEndpointService
        '''
        result = self._values.get("private_dns_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List[ISecurityGroup]]:
        '''The security groups to associate with this interface VPC endpoint.

        :default: - a new security group is created
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[ISecurityGroup]], result)

    @builtins.property
    def subnets(self) -> typing.Optional["SubnetSelection"]:
        '''The subnets in which to create an endpoint network interface.

        At most one
        per availability zone.

        :default: - private subnets
        '''
        result = self._values.get("subnets")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InterfaceVpcEndpointOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpointProps",
    jsii_struct_bases=[InterfaceVpcEndpointOptions],
    name_mapping={
        "service": "service",
        "lookup_supported_azs": "lookupSupportedAzs",
        "open": "open",
        "private_dns_enabled": "privateDnsEnabled",
        "security_groups": "securityGroups",
        "subnets": "subnets",
        "vpc": "vpc",
    },
)
class InterfaceVpcEndpointProps(InterfaceVpcEndpointOptions):
    def __init__(
        self,
        *,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
        vpc: IVpc,
    ) -> None:
        '''Construction properties for an InterfaceVpcEndpoint.

        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets
        :param vpc: The VPC network in which the interface endpoint will be used.

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            
            ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
                vpc=vpc,
                service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
                # Choose which availability zones to place the VPC endpoint in, based on
                # available AZs
                subnets=ec2.SubnetSelection(
                    availability_zones=["us-east-1a", "us-east-1c"]
                )
            )
        '''
        if isinstance(subnets, dict):
            subnets = SubnetSelection(**subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6606ba3de030c44ce43dee44afe64adc59231bfc542799d1354e0732a309b2f0)
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
            check_type(argname="argument lookup_supported_azs", value=lookup_supported_azs, expected_type=type_hints["lookup_supported_azs"])
            check_type(argname="argument open", value=open, expected_type=type_hints["open"])
            check_type(argname="argument private_dns_enabled", value=private_dns_enabled, expected_type=type_hints["private_dns_enabled"])
            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "service": service,
            "vpc": vpc,
        }
        if lookup_supported_azs is not None:
            self._values["lookup_supported_azs"] = lookup_supported_azs
        if open is not None:
            self._values["open"] = open
        if private_dns_enabled is not None:
            self._values["private_dns_enabled"] = private_dns_enabled
        if security_groups is not None:
            self._values["security_groups"] = security_groups
        if subnets is not None:
            self._values["subnets"] = subnets

    @builtins.property
    def service(self) -> IInterfaceVpcEndpointService:
        '''The service to use for this interface VPC endpoint.'''
        result = self._values.get("service")
        assert result is not None, "Required property 'service' is missing"
        return typing.cast(IInterfaceVpcEndpointService, result)

    @builtins.property
    def lookup_supported_azs(self) -> typing.Optional[builtins.bool]:
        '''Limit to only those availability zones where the endpoint service can be created.

        Setting this to 'true' requires a lookup to be performed at synthesis time. Account
        and region must be set on the containing stack for this to work.

        :default: false
        '''
        result = self._values.get("lookup_supported_azs")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def open(self) -> typing.Optional[builtins.bool]:
        '''Whether to automatically allow VPC traffic to the endpoint.

        If enabled, all traffic to the endpoint from within the VPC will be
        automatically allowed. This is done based on the VPC's CIDR range.

        :default: true
        '''
        result = self._values.get("open")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def private_dns_enabled(self) -> typing.Optional[builtins.bool]:
        '''Whether to associate a private hosted zone with the specified VPC.

        This
        allows you to make requests to the service using its default DNS hostname.

        :default:

        set by the instance of IInterfaceVpcEndpointService, or true if
        not defined by the instance of IInterfaceVpcEndpointService
        '''
        result = self._values.get("private_dns_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def security_groups(self) -> typing.Optional[typing.List[ISecurityGroup]]:
        '''The security groups to associate with this interface VPC endpoint.

        :default: - a new security group is created
        '''
        result = self._values.get("security_groups")
        return typing.cast(typing.Optional[typing.List[ISecurityGroup]], result)

    @builtins.property
    def subnets(self) -> typing.Optional["SubnetSelection"]:
        '''The subnets in which to create an endpoint network interface.

        At most one
        per availability zone.

        :default: - private subnets
        '''
        result = self._values.get("subnets")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    @builtins.property
    def vpc(self) -> IVpc:
        '''The VPC network in which the interface endpoint will be used.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast(IVpc, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InterfaceVpcEndpointProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IInterfaceVpcEndpointService)
class InterfaceVpcEndpointService(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpointService",
):
    '''A custom-hosted service for an interface VPC endpoint.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
            vpc=vpc,
            service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
            # Choose which availability zones to place the VPC endpoint in, based on
            # available AZs
            subnets=ec2.SubnetSelection(
                availability_zones=["us-east-1a", "us-east-1c"]
            )
        )
    '''

    def __init__(
        self,
        name: builtins.str,
        port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param name: The name of the service.
        :param port: The port of the service.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d463a2f9183f02e32ca03beb1752df250c2fb2c8b32f6f92dcc160804407c401)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        jsii.create(self.__class__, self, [name, port])

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="port")
    def port(self) -> jsii.Number:
        '''The port of the service.'''
        return typing.cast(jsii.Number, jsii.get(self, "port"))

    @builtins.property
    @jsii.member(jsii_name="privateDnsDefault")
    def private_dns_default(self) -> typing.Optional[builtins.bool]:
        '''Whether Private DNS is supported by default.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "privateDnsDefault"))


class IpAddresses(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.IpAddresses"):
    '''An abstract Provider of IpAddresses.

    Note this is specific to the IPv4 CIDR.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "TheVPC",
            # 'IpAddresses' configures the IP range and size of the entire VPC.
            # The IP space will be divided based on configuration for the subnets.
            ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/21"),
        
            # 'maxAzs' configures the maximum number of availability zones to use.
            # If you want to specify the exact availability zones you want the VPC
            # to use, use `availabilityZones` instead.
            max_azs=3,
        
            # 'subnetConfiguration' specifies the "subnet groups" to create.
            # Every subnet group will have a subnet for each AZ, so this
            # configuration will create `3 groups × 3 AZs = 9` subnets.
            subnet_configuration=[ec2.SubnetConfiguration(
                # 'subnetType' controls Internet access, as described above.
                subnet_type=ec2.SubnetType.PUBLIC,
        
                # 'name' is used to name this particular subnet group. You will have to
                # use the name for subnet selection if you have more than one subnet
                # group of the same type.
                name="Ingress",
        
                # 'cidrMask' specifies the IP addresses in the range of of individual
                # subnets in the group. Each of the subnets in this group will contain
                # `2^(32 address bits - 24 subnet bits) - 2 reserved addresses = 254`
                # usable IP addresses.
                #
                # If 'cidrMask' is left out the available address space is evenly
                # divided across the remaining subnet groups.
                cidr_mask=24
            ), ec2.SubnetConfiguration(
                cidr_mask=24,
                name="Application",
                subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
            ), ec2.SubnetConfiguration(
                cidr_mask=28,
                name="Database",
                subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
        
                # 'reserved' can be used to reserve IP address space. No resources will
                # be created for this subnet, but the IP range will be kept available for
                # future creation of this subnet, or even for future subdivision.
                reserved=True
            )
            ]
        )
    '''

    @jsii.member(jsii_name="awsIpamAllocation")
    @builtins.classmethod
    def aws_ipam_allocation(
        cls,
        *,
        ipv4_ipam_pool_id: builtins.str,
        ipv4_netmask_length: jsii.Number,
        default_subnet_ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ) -> IIpAddresses:
        '''Used to provide centralized Ip Address Management services for your VPC.

        Uses VPC CIDR allocations from AWS IPAM

        Note this is specific to the IPv4 CIDR.

        :param ipv4_ipam_pool_id: Ipam Pool Id for ipv4 allocation.
        :param ipv4_netmask_length: Netmask length for Vpc.
        :param default_subnet_ipv4_netmask_length: Default length for Subnet ipv4 Network mask. Specify this option only if you do not specify all Subnets using SubnetConfiguration with a cidrMask Default: - Default ipv4 Subnet Mask for subnets in Vpc

        :see: https://docs.aws.amazon.com/vpc/latest/ipam/what-it-is-ipam.html
        '''
        props = AwsIpamProps(
            ipv4_ipam_pool_id=ipv4_ipam_pool_id,
            ipv4_netmask_length=ipv4_netmask_length,
            default_subnet_ipv4_netmask_length=default_subnet_ipv4_netmask_length,
        )

        return typing.cast(IIpAddresses, jsii.sinvoke(cls, "awsIpamAllocation", [props]))

    @jsii.member(jsii_name="cidr")
    @builtins.classmethod
    def cidr(cls, cidr_block: builtins.str) -> IIpAddresses:
        '''Used to provide local Ip Address Management services for your VPC.

        VPC CIDR is supplied at creation and subnets are calculated locally

        Note this is specific to the IPv4 CIDR.

        :param cidr_block: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__712e8cdff0857893172d9de86affb30950183e037ef537789198de8ca49f9d41)
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
        return typing.cast(IIpAddresses, jsii.sinvoke(cls, "cidr", [cidr_block]))


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.IpProtocol")
class IpProtocol(enum.Enum):
    '''The types of IP addresses provisioned in the VPC.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "TheVPC",
            ip_protocol=ec2.IpProtocol.DUAL_STACK,
        
            subnet_configuration=[ec2.SubnetConfiguration(
                # general properties
                name="Public",
                subnet_type=ec2.SubnetType.PUBLIC,
                reserved=False,
        
                # IPv4 specific properties
                map_public_ip_on_launch=True,
                cidr_mask=24,
        
                # new IPv6 specific property
                ipv6_assign_address_on_creation=True
            )
            ]
        )
    '''

    IPV4_ONLY = "IPV4_ONLY"
    '''The vpc will be configured with only IPv4 addresses.

    This is the default protocol if unset.
    '''
    DUAL_STACK = "DUAL_STACK"
    '''The vpc will have both IPv4 and IPv6 addresses.

    Unless specified, public IPv4 addresses will not be auto assigned,
    an egress only internet gateway (EIGW) will be created and configured,
    and NATs and internet gateways (IGW) will be configured with IPv6 addresses.
    '''


class Ipv6Addresses(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.Ipv6Addresses",
):
    '''An abstract Provider of Ipv6Addresses.

    Note this is specific to the IPv6 CIDR.
    '''

    @jsii.member(jsii_name="amazonProvided")
    @builtins.classmethod
    def amazon_provided(cls) -> IIpv6Addresses:
        '''Used for IPv6 address management with Amazon provided CIDRs.

        Note this is specific to the IPv6 CIDR.
        '''
        return typing.cast(IIpv6Addresses, jsii.sinvoke(cls, "amazonProvided", []))


@jsii.implements(IKeyPair)
class KeyPair(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.KeyPair",
):
    '''An EC2 Key Pair.

    :resource: AWS::EC2::KeyPair
    :exampleMetadata: infused

    Example::

        key_pair = ec2.KeyPair.from_key_pair_attributes(self, "KeyPair",
            key_pair_name="the-keypair-name",
            type=ec2.KeyPairType.RSA
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        format: typing.Optional["KeyPairFormat"] = None,
        key_pair_name: typing.Optional[builtins.str] = None,
        public_key_material: typing.Optional[builtins.str] = None,
        type: typing.Optional["KeyPairType"] = None,
        account: typing.Optional[builtins.str] = None,
        environment_from_arn: typing.Optional[builtins.str] = None,
        physical_name: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param format: The format of the key pair. Default: PEM
        :param key_pair_name: A unique name for the key pair. Default: A generated name
        :param public_key_material: The public key material. If this is provided the key is considered "imported". For imported keys, it is assumed that you already have the private key material so the private key material will not be returned or stored in AWS Systems Manager Parameter Store. Default: a public and private key will be generated
        :param type: The type of key pair. Default: RSA (ignored if keyMaterial is provided)
        :param account: The AWS account ID this resource belongs to. Default: - the resource is in the same account as the stack it belongs to
        :param environment_from_arn: ARN to deduce region and account from. The ARN is parsed and the account and region are taken from the ARN. This should be used for imported resources. Cannot be supplied together with either ``account`` or ``region``. Default: - take environment from ``account``, ``region`` parameters, or use Stack environment.
        :param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated by CloudFormation during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation. Default: - The physical name will be allocated by CloudFormation at deployment time
        :param region: The AWS region this resource belongs to. Default: - the resource is in the same region as the stack it belongs to
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__723c12f80f8f69703f74949dec0a4305b19d6d27efff9d36830815d8e604283c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = KeyPairProps(
            format=format,
            key_pair_name=key_pair_name,
            public_key_material=public_key_material,
            type=type,
            account=account,
            environment_from_arn=environment_from_arn,
            physical_name=physical_name,
            region=region,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromKeyPairAttributes")
    @builtins.classmethod
    def from_key_pair_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        key_pair_name: builtins.str,
        type: typing.Optional["KeyPairType"] = None,
    ) -> IKeyPair:
        '''Imports a key pair with a name and optional type.

        :param scope: -
        :param id: -
        :param key_pair_name: The unique name of the key pair.
        :param type: The type of the key pair. Default: no type specified
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12d377269b610c395f1583e904a11636e952288b5e3f85a3cc1d865eb21f7715)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = KeyPairAttributes(key_pair_name=key_pair_name, type=type)

        return typing.cast(IKeyPair, jsii.sinvoke(cls, "fromKeyPairAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="fromKeyPairName")
    @builtins.classmethod
    def from_key_pair_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        key_pair_name: builtins.str,
    ) -> IKeyPair:
        '''Imports a key pair based on the name.

        :param scope: -
        :param id: -
        :param key_pair_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7bcad8d69b7ac63eda9832fb42b2e78a5f5570d5ccd5ac181f25d55202b6f74c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument key_pair_name", value=key_pair_name, expected_type=type_hints["key_pair_name"])
        return typing.cast(IKeyPair, jsii.sinvoke(cls, "fromKeyPairName", [scope, id, key_pair_name]))

    @builtins.property
    @jsii.member(jsii_name="format")
    def format(self) -> "KeyPairFormat":
        '''The format of the key pair.'''
        return typing.cast("KeyPairFormat", jsii.get(self, "format"))

    @builtins.property
    @jsii.member(jsii_name="hasImportedMaterial")
    def has_imported_material(self) -> builtins.bool:
        '''Whether the key material was imported.

        Keys with imported material do not have their private key material stored
        or returned automatically.
        '''
        return typing.cast(builtins.bool, jsii.get(self, "hasImportedMaterial"))

    @builtins.property
    @jsii.member(jsii_name="keyPairFingerprint")
    def key_pair_fingerprint(self) -> builtins.str:
        '''The fingerprint of the key pair.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "keyPairFingerprint"))

    @builtins.property
    @jsii.member(jsii_name="keyPairId")
    def key_pair_id(self) -> builtins.str:
        '''The unique ID of the key pair.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "keyPairId"))

    @builtins.property
    @jsii.member(jsii_name="keyPairName")
    def key_pair_name(self) -> builtins.str:
        '''The unique name of the key pair.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "keyPairName"))

    @builtins.property
    @jsii.member(jsii_name="privateKey")
    def private_key(self) -> _IStringParameter_f2b707f9:
        '''The Systems Manager Parameter Store parameter with the pair's private key material.'''
        return typing.cast(_IStringParameter_f2b707f9, jsii.get(self, "privateKey"))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> typing.Optional["KeyPairType"]:
        '''The type of the key pair.'''
        return typing.cast(typing.Optional["KeyPairType"], jsii.get(self, "type"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.KeyPairAttributes",
    jsii_struct_bases=[],
    name_mapping={"key_pair_name": "keyPairName", "type": "type"},
)
class KeyPairAttributes:
    def __init__(
        self,
        *,
        key_pair_name: builtins.str,
        type: typing.Optional["KeyPairType"] = None,
    ) -> None:
        '''Attributes of a Key Pair.

        :param key_pair_name: The unique name of the key pair.
        :param type: The type of the key pair. Default: no type specified

        :exampleMetadata: infused

        Example::

            key_pair = ec2.KeyPair.from_key_pair_attributes(self, "KeyPair",
                key_pair_name="the-keypair-name",
                type=ec2.KeyPairType.RSA
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c0b1d2207b185c203475dcfffe01485ff1d6dd460f5c0308f88afbd59667178)
            check_type(argname="argument key_pair_name", value=key_pair_name, expected_type=type_hints["key_pair_name"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "key_pair_name": key_pair_name,
        }
        if type is not None:
            self._values["type"] = type

    @builtins.property
    def key_pair_name(self) -> builtins.str:
        '''The unique name of the key pair.'''
        result = self._values.get("key_pair_name")
        assert result is not None, "Required property 'key_pair_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def type(self) -> typing.Optional["KeyPairType"]:
        '''The type of the key pair.

        :default: no type specified
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional["KeyPairType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KeyPairAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.KeyPairFormat")
class KeyPairFormat(enum.Enum):
    '''The format of the Key Pair.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        key_pair = ec2.KeyPair(self, "KeyPair",
            type=ec2.KeyPairType.ED25519,
            format=ec2.KeyPairFormat.PEM
        )
        instance = ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
            # Use the custom key pair
            key_pair=key_pair
        )
    '''

    PPK = "PPK"
    '''A PPK file, typically used with PuTTY.'''
    PEM = "PEM"
    '''A PEM file.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.KeyPairProps",
    jsii_struct_bases=[_ResourceProps_15a65b4e],
    name_mapping={
        "account": "account",
        "environment_from_arn": "environmentFromArn",
        "physical_name": "physicalName",
        "region": "region",
        "format": "format",
        "key_pair_name": "keyPairName",
        "public_key_material": "publicKeyMaterial",
        "type": "type",
    },
)
class KeyPairProps(_ResourceProps_15a65b4e):
    def __init__(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        environment_from_arn: typing.Optional[builtins.str] = None,
        physical_name: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        format: typing.Optional[KeyPairFormat] = None,
        key_pair_name: typing.Optional[builtins.str] = None,
        public_key_material: typing.Optional[builtins.str] = None,
        type: typing.Optional["KeyPairType"] = None,
    ) -> None:
        '''The properties of a Key Pair.

        :param account: The AWS account ID this resource belongs to. Default: - the resource is in the same account as the stack it belongs to
        :param environment_from_arn: ARN to deduce region and account from. The ARN is parsed and the account and region are taken from the ARN. This should be used for imported resources. Cannot be supplied together with either ``account`` or ``region``. Default: - take environment from ``account``, ``region`` parameters, or use Stack environment.
        :param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated by CloudFormation during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation. Default: - The physical name will be allocated by CloudFormation at deployment time
        :param region: The AWS region this resource belongs to. Default: - the resource is in the same region as the stack it belongs to
        :param format: The format of the key pair. Default: PEM
        :param key_pair_name: A unique name for the key pair. Default: A generated name
        :param public_key_material: The public key material. If this is provided the key is considered "imported". For imported keys, it is assumed that you already have the private key material so the private key material will not be returned or stored in AWS Systems Manager Parameter Store. Default: a public and private key will be generated
        :param type: The type of key pair. Default: RSA (ignored if keyMaterial is provided)

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            # instance_type: ec2.InstanceType
            
            
            key_pair = ec2.KeyPair(self, "KeyPair",
                type=ec2.KeyPairType.ED25519,
                format=ec2.KeyPairFormat.PEM
            )
            instance = ec2.Instance(self, "Instance",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=ec2.MachineImage.latest_amazon_linux2023(),
                # Use the custom key pair
                key_pair=key_pair
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7af23eb9509f044383945f68d46a72f0c94f0542177c255d3d31b42f5e9aa98c)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument environment_from_arn", value=environment_from_arn, expected_type=type_hints["environment_from_arn"])
            check_type(argname="argument physical_name", value=physical_name, expected_type=type_hints["physical_name"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument format", value=format, expected_type=type_hints["format"])
            check_type(argname="argument key_pair_name", value=key_pair_name, expected_type=type_hints["key_pair_name"])
            check_type(argname="argument public_key_material", value=public_key_material, expected_type=type_hints["public_key_material"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if account is not None:
            self._values["account"] = account
        if environment_from_arn is not None:
            self._values["environment_from_arn"] = environment_from_arn
        if physical_name is not None:
            self._values["physical_name"] = physical_name
        if region is not None:
            self._values["region"] = region
        if format is not None:
            self._values["format"] = format
        if key_pair_name is not None:
            self._values["key_pair_name"] = key_pair_name
        if public_key_material is not None:
            self._values["public_key_material"] = public_key_material
        if type is not None:
            self._values["type"] = type

    @builtins.property
    def account(self) -> typing.Optional[builtins.str]:
        '''The AWS account ID this resource belongs to.

        :default: - the resource is in the same account as the stack it belongs to
        '''
        result = self._values.get("account")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def environment_from_arn(self) -> typing.Optional[builtins.str]:
        '''ARN to deduce region and account from.

        The ARN is parsed and the account and region are taken from the ARN.
        This should be used for imported resources.

        Cannot be supplied together with either ``account`` or ``region``.

        :default: - take environment from ``account``, ``region`` parameters, or use Stack environment.
        '''
        result = self._values.get("environment_from_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def physical_name(self) -> typing.Optional[builtins.str]:
        '''The value passed in by users to the physical name prop of the resource.

        - ``undefined`` implies that a physical name will be allocated by
          CloudFormation during deployment.
        - a concrete value implies a specific physical name
        - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated
          by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation.

        :default: - The physical name will be allocated by CloudFormation at deployment time
        '''
        result = self._values.get("physical_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''The AWS region this resource belongs to.

        :default: - the resource is in the same region as the stack it belongs to
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def format(self) -> typing.Optional[KeyPairFormat]:
        '''The format of the key pair.

        :default: PEM
        '''
        result = self._values.get("format")
        return typing.cast(typing.Optional[KeyPairFormat], result)

    @builtins.property
    def key_pair_name(self) -> typing.Optional[builtins.str]:
        '''A unique name for the key pair.

        :default: A generated name
        '''
        result = self._values.get("key_pair_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def public_key_material(self) -> typing.Optional[builtins.str]:
        '''The public key material.

        If this is provided the key is considered "imported". For imported
        keys, it is assumed that you already have the private key material
        so the private key material will not be returned or stored in
        AWS Systems Manager Parameter Store.

        :default: a public and private key will be generated
        '''
        result = self._values.get("public_key_material")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def type(self) -> typing.Optional["KeyPairType"]:
        '''The type of key pair.

        :default: RSA (ignored if keyMaterial is provided)
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional["KeyPairType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KeyPairProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.KeyPairType")
class KeyPairType(enum.Enum):
    '''The type of the key pair.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        key_pair = ec2.KeyPair(self, "KeyPair",
            type=ec2.KeyPairType.ED25519,
            format=ec2.KeyPairFormat.PEM
        )
        instance = ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
            # Use the custom key pair
            key_pair=key_pair
        )
    '''

    RSA = "RSA"
    '''An RSA key.'''
    ED25519 = "ED25519"
    '''An ED25519 key.

    Note that ED25519 keys are not supported for Windows instances.
    '''


@jsii.implements(ILaunchTemplate, _IGrantable_71c4f5de, IConnectable)
class LaunchTemplate(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplate",
):
    '''This represents an EC2 LaunchTemplate.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html
    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        sg1 = ec2.SecurityGroup(self, "sg1",
            vpc=vpc
        )
        sg2 = ec2.SecurityGroup(self, "sg2",
            vpc=vpc
        )
        
        launch_template = ec2.LaunchTemplate(self, "LaunchTemplate",
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
            security_group=sg1
        )
        
        launch_template.add_security_group(sg2)
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        associate_public_ip_address: typing.Optional[builtins.bool] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
        cpu_credits: typing.Optional[CpuCredits] = None,
        detailed_monitoring: typing.Optional[builtins.bool] = None,
        disable_api_termination: typing.Optional[builtins.bool] = None,
        ebs_optimized: typing.Optional[builtins.bool] = None,
        hibernation_configured: typing.Optional[builtins.bool] = None,
        http_endpoint: typing.Optional[builtins.bool] = None,
        http_protocol_ipv6: typing.Optional[builtins.bool] = None,
        http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
        http_tokens: typing.Optional["LaunchTemplateHttpTokens"] = None,
        instance_initiated_shutdown_behavior: typing.Optional[InstanceInitiatedShutdownBehavior] = None,
        instance_metadata_tags: typing.Optional[builtins.bool] = None,
        instance_profile: typing.Optional[_IInstanceProfile_10d5ce2c] = None,
        instance_type: typing.Optional[InstanceType] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        launch_template_name: typing.Optional[builtins.str] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        nitro_enclave_enabled: typing.Optional[builtins.bool] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        role: typing.Optional[_IRole_235f5d8e] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
        spot_options: typing.Optional[typing.Union["LaunchTemplateSpotOptions", typing.Dict[builtins.str, typing.Any]]] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param associate_public_ip_address: Whether instances should have a public IP addresses associated with them. Default: - Use subnet settings
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param cpu_credits: CPU credit type for burstable EC2 instance types. Default: - No credit type is specified in the Launch Template.
        :param detailed_monitoring: If set to true, then detailed monitoring will be enabled on instances created with this launch template. Default: False - Detailed monitoring is disabled.
        :param disable_api_termination: If you set this parameter to true, you cannot terminate the instances launched with this launch template using the Amazon EC2 console, CLI, or API; otherwise, you can. Default: - The API termination setting is not specified in the Launch Template.
        :param ebs_optimized: Indicates whether the instances are optimized for Amazon EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance. Default: - EBS optimization is not specified in the launch template.
        :param hibernation_configured: If you set this parameter to true, the instance is enabled for hibernation. Default: - Hibernation configuration is not specified in the launch template; defaulting to false.
        :param http_endpoint: Enables or disables the HTTP metadata endpoint on your instances. Default: true
        :param http_protocol_ipv6: Enables or disables the IPv6 endpoint for the instance metadata service. Default: true
        :param http_put_response_hop_limit: The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel. Default: 1
        :param http_tokens: The state of token usage for your instance metadata requests. The default state is ``optional`` if not specified. However, if requireImdsv2 is true, the state must be ``required``. Default: LaunchTemplateHttpTokens.OPTIONAL
        :param instance_initiated_shutdown_behavior: Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Default: - Shutdown behavior is not specified in the launch template; defaults to STOP.
        :param instance_metadata_tags: Set to enabled to allow access to instance tags from the instance metadata. Set to disabled to turn off access to instance tags from the instance metadata. Default: false
        :param instance_profile: The instance profile used to pass role information to EC2 instances. Note: You can provide an instanceProfile or a role, but not both. Default: - No instance profile
        :param instance_type: Type of instance to launch. Default: - This Launch Template does not specify a default Instance Type.
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param launch_template_name: Name for this launch template. Default: Automatically generated name
        :param machine_image: The AMI that will be used by instances. Default: - This Launch Template does not specify a default AMI.
        :param nitro_enclave_enabled: If this parameter is set to true, the instance is enabled for AWS Nitro Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves. Default: - Enablement of Nitro enclaves is not specified in the launch template; defaulting to false.
        :param require_imdsv2: Whether IMDSv2 should be required on launched instances. Default: - false
        :param role: An IAM role to associate with the instance profile that is used by instances. The role must be assumable by the service principal ``ec2.amazonaws.com``. Note: You can provide an instanceProfile or a role, but not both. Default: - No new role is created.
        :param security_group: Security group to assign to instances created with the launch template. Default: No security group is assigned.
        :param spot_options: If this property is defined, then the Launch Template's InstanceMarketOptions will be set to use Spot instances, and the options for the Spot instances will be as defined. Default: - Instance launched with this template will not be spot instances.
        :param user_data: The AMI that will be used by instances. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__544aef11081ec87047935491f75a3d5bc9d5075de77f96969bd2ffd1a0d78cc9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = LaunchTemplateProps(
            associate_public_ip_address=associate_public_ip_address,
            block_devices=block_devices,
            cpu_credits=cpu_credits,
            detailed_monitoring=detailed_monitoring,
            disable_api_termination=disable_api_termination,
            ebs_optimized=ebs_optimized,
            hibernation_configured=hibernation_configured,
            http_endpoint=http_endpoint,
            http_protocol_ipv6=http_protocol_ipv6,
            http_put_response_hop_limit=http_put_response_hop_limit,
            http_tokens=http_tokens,
            instance_initiated_shutdown_behavior=instance_initiated_shutdown_behavior,
            instance_metadata_tags=instance_metadata_tags,
            instance_profile=instance_profile,
            instance_type=instance_type,
            key_name=key_name,
            key_pair=key_pair,
            launch_template_name=launch_template_name,
            machine_image=machine_image,
            nitro_enclave_enabled=nitro_enclave_enabled,
            require_imdsv2=require_imdsv2,
            role=role,
            security_group=security_group,
            spot_options=spot_options,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromLaunchTemplateAttributes")
    @builtins.classmethod
    def from_launch_template_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        launch_template_id: typing.Optional[builtins.str] = None,
        launch_template_name: typing.Optional[builtins.str] = None,
        version_number: typing.Optional[builtins.str] = None,
    ) -> ILaunchTemplate:
        '''Import an existing LaunchTemplate.

        :param scope: -
        :param id: -
        :param launch_template_id: The identifier of the Launch Template. Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set. Default: None
        :param launch_template_name: The name of the Launch Template. Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set. Default: None
        :param version_number: The version number of this launch template to use. Default: Version: "$Default"
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c5bafc86e1cbb0e73c75092f8c58aca75ee08a032f755bf4acdadd68719d2e2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = LaunchTemplateAttributes(
            launch_template_id=launch_template_id,
            launch_template_name=launch_template_name,
            version_number=version_number,
        )

        return typing.cast(ILaunchTemplate, jsii.sinvoke(cls, "fromLaunchTemplateAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="addSecurityGroup")
    def add_security_group(self, security_group: ISecurityGroup) -> None:
        '''Add the security group to the instance.

        :param security_group: : The security group to add.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9dd55f9f3b4519a893a859b46b35d0cbfb7aef6ebf26d57097c50fb4b9e2f353)
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
        return typing.cast(None, jsii.invoke(self, "addSecurityGroup", [security_group]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''Allows specifying security group connections for the instance.

        :note: Only available if you provide a securityGroup when constructing the LaunchTemplate.
        '''
        return typing.cast("Connections", jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="defaultVersionNumber")
    def default_version_number(self) -> builtins.str:
        '''The default version for the launch template.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "defaultVersionNumber"))

    @builtins.property
    @jsii.member(jsii_name="grantPrincipal")
    def grant_principal(self) -> _IPrincipal_539bb2fd:
        '''Principal to grant permissions to.

        :note: Only available if you provide a role when constructing the LaunchTemplate.
        '''
        return typing.cast(_IPrincipal_539bb2fd, jsii.get(self, "grantPrincipal"))

    @builtins.property
    @jsii.member(jsii_name="latestVersionNumber")
    def latest_version_number(self) -> builtins.str:
        '''The latest version of the launch template.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "latestVersionNumber"))

    @builtins.property
    @jsii.member(jsii_name="tags")
    def _tags(self) -> _TagManager_0a598cb3:
        '''TagManager for tagging support.'''
        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))

    @builtins.property
    @jsii.member(jsii_name="versionNumber")
    def version_number(self) -> builtins.str:
        '''The version number of this launch template to use.'''
        return typing.cast(builtins.str, jsii.get(self, "versionNumber"))

    @builtins.property
    @jsii.member(jsii_name="imageId")
    def image_id(self) -> typing.Optional[builtins.str]:
        '''The AMI ID of the image to use.

        :attribute: true
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "imageId"))

    @builtins.property
    @jsii.member(jsii_name="instanceType")
    def instance_type(self) -> typing.Optional[InstanceType]:
        '''Type of instance to launch.

        :attribute: true
        '''
        return typing.cast(typing.Optional[InstanceType], jsii.get(self, "instanceType"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateId")
    def launch_template_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "launchTemplateId"))

    @builtins.property
    @jsii.member(jsii_name="launchTemplateName")
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''The name of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` will be set.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "launchTemplateName"))

    @builtins.property
    @jsii.member(jsii_name="osType")
    def os_type(self) -> typing.Optional["OperatingSystemType"]:
        '''The type of OS the instance is running.

        :attribute: true
        '''
        return typing.cast(typing.Optional["OperatingSystemType"], jsii.get(self, "osType"))

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> typing.Optional[_IRole_235f5d8e]:
        '''IAM Role assumed by instances that are launched from this template.

        :attribute: true
        '''
        return typing.cast(typing.Optional[_IRole_235f5d8e], jsii.get(self, "role"))

    @builtins.property
    @jsii.member(jsii_name="userData")
    def user_data(self) -> typing.Optional["UserData"]:
        '''UserData executed by instances that are launched from this template.

        :attribute: true
        '''
        return typing.cast(typing.Optional["UserData"], jsii.get(self, "userData"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "launch_template_id": "launchTemplateId",
        "launch_template_name": "launchTemplateName",
        "version_number": "versionNumber",
    },
)
class LaunchTemplateAttributes:
    def __init__(
        self,
        *,
        launch_template_id: typing.Optional[builtins.str] = None,
        launch_template_name: typing.Optional[builtins.str] = None,
        version_number: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Attributes for an imported LaunchTemplate.

        :param launch_template_id: The identifier of the Launch Template. Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set. Default: None
        :param launch_template_name: The name of the Launch Template. Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set. Default: None
        :param version_number: The version number of this launch template to use. Default: Version: "$Default"

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            launch_template_attributes = ec2.LaunchTemplateAttributes(
                launch_template_id="launchTemplateId",
                launch_template_name="launchTemplateName",
                version_number="versionNumber"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__59e32b8d80664a9fec0a3a5774b331fef386ee6f11bdc1bdbd15a956dae7d41d)
            check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
            check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            check_type(argname="argument version_number", value=version_number, expected_type=type_hints["version_number"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if launch_template_id is not None:
            self._values["launch_template_id"] = launch_template_id
        if launch_template_name is not None:
            self._values["launch_template_name"] = launch_template_name
        if version_number is not None:
            self._values["version_number"] = version_number

    @builtins.property
    def launch_template_id(self) -> typing.Optional[builtins.str]:
        '''The identifier of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set.

        :default: None
        '''
        result = self._values.get("launch_template_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''The name of the Launch Template.

        Exactly one of ``launchTemplateId`` and ``launchTemplateName`` may be set.

        :default: None
        '''
        result = self._values.get("launch_template_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def version_number(self) -> typing.Optional[builtins.str]:
        '''The version number of this launch template to use.

        :default: Version: "$Default"
        '''
        result = self._values.get("version_number")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LaunchTemplateAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateHttpTokens")
class LaunchTemplateHttpTokens(enum.Enum):
    '''The state of token usage for your instance metadata requests.

    :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httptokens
    :exampleMetadata: infused

    Example::

        ec2.LaunchTemplate(self, "LaunchTemplate",
            http_endpoint=True,
            http_protocol_ipv6=True,
            http_put_response_hop_limit=1,
            http_tokens=ec2.LaunchTemplateHttpTokens.REQUIRED,
            instance_metadata_tags=True
        )
    '''

    OPTIONAL = "OPTIONAL"
    '''If the state is optional, you can choose to retrieve instance metadata with or without a signed token header on your request.'''
    REQUIRED = "REQUIRED"
    '''If the state is required, you must send a signed token header with any instance metadata retrieval requests.

    In this state,
    retrieving the IAM role credentials always returns the version 2.0 credentials; the version 1.0 credentials are not available.
    '''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateProps",
    jsii_struct_bases=[],
    name_mapping={
        "associate_public_ip_address": "associatePublicIpAddress",
        "block_devices": "blockDevices",
        "cpu_credits": "cpuCredits",
        "detailed_monitoring": "detailedMonitoring",
        "disable_api_termination": "disableApiTermination",
        "ebs_optimized": "ebsOptimized",
        "hibernation_configured": "hibernationConfigured",
        "http_endpoint": "httpEndpoint",
        "http_protocol_ipv6": "httpProtocolIpv6",
        "http_put_response_hop_limit": "httpPutResponseHopLimit",
        "http_tokens": "httpTokens",
        "instance_initiated_shutdown_behavior": "instanceInitiatedShutdownBehavior",
        "instance_metadata_tags": "instanceMetadataTags",
        "instance_profile": "instanceProfile",
        "instance_type": "instanceType",
        "key_name": "keyName",
        "key_pair": "keyPair",
        "launch_template_name": "launchTemplateName",
        "machine_image": "machineImage",
        "nitro_enclave_enabled": "nitroEnclaveEnabled",
        "require_imdsv2": "requireImdsv2",
        "role": "role",
        "security_group": "securityGroup",
        "spot_options": "spotOptions",
        "user_data": "userData",
    },
)
class LaunchTemplateProps:
    def __init__(
        self,
        *,
        associate_public_ip_address: typing.Optional[builtins.bool] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
        cpu_credits: typing.Optional[CpuCredits] = None,
        detailed_monitoring: typing.Optional[builtins.bool] = None,
        disable_api_termination: typing.Optional[builtins.bool] = None,
        ebs_optimized: typing.Optional[builtins.bool] = None,
        hibernation_configured: typing.Optional[builtins.bool] = None,
        http_endpoint: typing.Optional[builtins.bool] = None,
        http_protocol_ipv6: typing.Optional[builtins.bool] = None,
        http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
        http_tokens: typing.Optional[LaunchTemplateHttpTokens] = None,
        instance_initiated_shutdown_behavior: typing.Optional[InstanceInitiatedShutdownBehavior] = None,
        instance_metadata_tags: typing.Optional[builtins.bool] = None,
        instance_profile: typing.Optional[_IInstanceProfile_10d5ce2c] = None,
        instance_type: typing.Optional[InstanceType] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        launch_template_name: typing.Optional[builtins.str] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        nitro_enclave_enabled: typing.Optional[builtins.bool] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        role: typing.Optional[_IRole_235f5d8e] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
        spot_options: typing.Optional[typing.Union["LaunchTemplateSpotOptions", typing.Dict[builtins.str, typing.Any]]] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> None:
        '''Properties of a LaunchTemplate.

        :param associate_public_ip_address: Whether instances should have a public IP addresses associated with them. Default: - Use subnet settings
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param cpu_credits: CPU credit type for burstable EC2 instance types. Default: - No credit type is specified in the Launch Template.
        :param detailed_monitoring: If set to true, then detailed monitoring will be enabled on instances created with this launch template. Default: False - Detailed monitoring is disabled.
        :param disable_api_termination: If you set this parameter to true, you cannot terminate the instances launched with this launch template using the Amazon EC2 console, CLI, or API; otherwise, you can. Default: - The API termination setting is not specified in the Launch Template.
        :param ebs_optimized: Indicates whether the instances are optimized for Amazon EBS I/O. This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance. Default: - EBS optimization is not specified in the launch template.
        :param hibernation_configured: If you set this parameter to true, the instance is enabled for hibernation. Default: - Hibernation configuration is not specified in the launch template; defaulting to false.
        :param http_endpoint: Enables or disables the HTTP metadata endpoint on your instances. Default: true
        :param http_protocol_ipv6: Enables or disables the IPv6 endpoint for the instance metadata service. Default: true
        :param http_put_response_hop_limit: The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel. Default: 1
        :param http_tokens: The state of token usage for your instance metadata requests. The default state is ``optional`` if not specified. However, if requireImdsv2 is true, the state must be ``required``. Default: LaunchTemplateHttpTokens.OPTIONAL
        :param instance_initiated_shutdown_behavior: Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Default: - Shutdown behavior is not specified in the launch template; defaults to STOP.
        :param instance_metadata_tags: Set to enabled to allow access to instance tags from the instance metadata. Set to disabled to turn off access to instance tags from the instance metadata. Default: false
        :param instance_profile: The instance profile used to pass role information to EC2 instances. Note: You can provide an instanceProfile or a role, but not both. Default: - No instance profile
        :param instance_type: Type of instance to launch. Default: - This Launch Template does not specify a default Instance Type.
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param launch_template_name: Name for this launch template. Default: Automatically generated name
        :param machine_image: The AMI that will be used by instances. Default: - This Launch Template does not specify a default AMI.
        :param nitro_enclave_enabled: If this parameter is set to true, the instance is enabled for AWS Nitro Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves. Default: - Enablement of Nitro enclaves is not specified in the launch template; defaulting to false.
        :param require_imdsv2: Whether IMDSv2 should be required on launched instances. Default: - false
        :param role: An IAM role to associate with the instance profile that is used by instances. The role must be assumable by the service principal ``ec2.amazonaws.com``. Note: You can provide an instanceProfile or a role, but not both. Default: - No new role is created.
        :param security_group: Security group to assign to instances created with the launch template. Default: No security group is assigned.
        :param spot_options: If this property is defined, then the Launch Template's InstanceMarketOptions will be set to use Spot instances, and the options for the Spot instances will be as defined. Default: - Instance launched with this template will not be spot instances.
        :param user_data: The AMI that will be used by instances. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            
            sg1 = ec2.SecurityGroup(self, "sg1",
                vpc=vpc
            )
            sg2 = ec2.SecurityGroup(self, "sg2",
                vpc=vpc
            )
            
            launch_template = ec2.LaunchTemplate(self, "LaunchTemplate",
                machine_image=ec2.MachineImage.latest_amazon_linux2023(),
                security_group=sg1
            )
            
            launch_template.add_security_group(sg2)
        '''
        if isinstance(spot_options, dict):
            spot_options = LaunchTemplateSpotOptions(**spot_options)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2ebb1bf0fbb2f9e894169a610cd9fb7cc3f827d34d3a10351bd2f5174d9b3ae)
            check_type(argname="argument associate_public_ip_address", value=associate_public_ip_address, expected_type=type_hints["associate_public_ip_address"])
            check_type(argname="argument block_devices", value=block_devices, expected_type=type_hints["block_devices"])
            check_type(argname="argument cpu_credits", value=cpu_credits, expected_type=type_hints["cpu_credits"])
            check_type(argname="argument detailed_monitoring", value=detailed_monitoring, expected_type=type_hints["detailed_monitoring"])
            check_type(argname="argument disable_api_termination", value=disable_api_termination, expected_type=type_hints["disable_api_termination"])
            check_type(argname="argument ebs_optimized", value=ebs_optimized, expected_type=type_hints["ebs_optimized"])
            check_type(argname="argument hibernation_configured", value=hibernation_configured, expected_type=type_hints["hibernation_configured"])
            check_type(argname="argument http_endpoint", value=http_endpoint, expected_type=type_hints["http_endpoint"])
            check_type(argname="argument http_protocol_ipv6", value=http_protocol_ipv6, expected_type=type_hints["http_protocol_ipv6"])
            check_type(argname="argument http_put_response_hop_limit", value=http_put_response_hop_limit, expected_type=type_hints["http_put_response_hop_limit"])
            check_type(argname="argument http_tokens", value=http_tokens, expected_type=type_hints["http_tokens"])
            check_type(argname="argument instance_initiated_shutdown_behavior", value=instance_initiated_shutdown_behavior, expected_type=type_hints["instance_initiated_shutdown_behavior"])
            check_type(argname="argument instance_metadata_tags", value=instance_metadata_tags, expected_type=type_hints["instance_metadata_tags"])
            check_type(argname="argument instance_profile", value=instance_profile, expected_type=type_hints["instance_profile"])
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
            check_type(argname="argument key_pair", value=key_pair, expected_type=type_hints["key_pair"])
            check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
            check_type(argname="argument machine_image", value=machine_image, expected_type=type_hints["machine_image"])
            check_type(argname="argument nitro_enclave_enabled", value=nitro_enclave_enabled, expected_type=type_hints["nitro_enclave_enabled"])
            check_type(argname="argument require_imdsv2", value=require_imdsv2, expected_type=type_hints["require_imdsv2"])
            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
            check_type(argname="argument spot_options", value=spot_options, expected_type=type_hints["spot_options"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if associate_public_ip_address is not None:
            self._values["associate_public_ip_address"] = associate_public_ip_address
        if block_devices is not None:
            self._values["block_devices"] = block_devices
        if cpu_credits is not None:
            self._values["cpu_credits"] = cpu_credits
        if detailed_monitoring is not None:
            self._values["detailed_monitoring"] = detailed_monitoring
        if disable_api_termination is not None:
            self._values["disable_api_termination"] = disable_api_termination
        if ebs_optimized is not None:
            self._values["ebs_optimized"] = ebs_optimized
        if hibernation_configured is not None:
            self._values["hibernation_configured"] = hibernation_configured
        if http_endpoint is not None:
            self._values["http_endpoint"] = http_endpoint
        if http_protocol_ipv6 is not None:
            self._values["http_protocol_ipv6"] = http_protocol_ipv6
        if http_put_response_hop_limit is not None:
            self._values["http_put_response_hop_limit"] = http_put_response_hop_limit
        if http_tokens is not None:
            self._values["http_tokens"] = http_tokens
        if instance_initiated_shutdown_behavior is not None:
            self._values["instance_initiated_shutdown_behavior"] = instance_initiated_shutdown_behavior
        if instance_metadata_tags is not None:
            self._values["instance_metadata_tags"] = instance_metadata_tags
        if instance_profile is not None:
            self._values["instance_profile"] = instance_profile
        if instance_type is not None:
            self._values["instance_type"] = instance_type
        if key_name is not None:
            self._values["key_name"] = key_name
        if key_pair is not None:
            self._values["key_pair"] = key_pair
        if launch_template_name is not None:
            self._values["launch_template_name"] = launch_template_name
        if machine_image is not None:
            self._values["machine_image"] = machine_image
        if nitro_enclave_enabled is not None:
            self._values["nitro_enclave_enabled"] = nitro_enclave_enabled
        if require_imdsv2 is not None:
            self._values["require_imdsv2"] = require_imdsv2
        if role is not None:
            self._values["role"] = role
        if security_group is not None:
            self._values["security_group"] = security_group
        if spot_options is not None:
            self._values["spot_options"] = spot_options
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def associate_public_ip_address(self) -> typing.Optional[builtins.bool]:
        '''Whether instances should have a public IP addresses associated with them.

        :default: - Use subnet settings
        '''
        result = self._values.get("associate_public_ip_address")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def block_devices(self) -> typing.Optional[typing.List[BlockDevice]]:
        '''Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.

        Each instance that is launched has an associated root device volume,
        either an Amazon EBS volume or an instance store volume.
        You can use block device mappings to specify additional EBS volumes or
        instance store volumes to attach to an instance when it is launched.

        :default: - Uses the block device mapping of the AMI

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html
        '''
        result = self._values.get("block_devices")
        return typing.cast(typing.Optional[typing.List[BlockDevice]], result)

    @builtins.property
    def cpu_credits(self) -> typing.Optional[CpuCredits]:
        '''CPU credit type for burstable EC2 instance types.

        :default: - No credit type is specified in the Launch Template.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html
        '''
        result = self._values.get("cpu_credits")
        return typing.cast(typing.Optional[CpuCredits], result)

    @builtins.property
    def detailed_monitoring(self) -> typing.Optional[builtins.bool]:
        '''If set to true, then detailed monitoring will be enabled on instances created with this launch template.

        :default: False - Detailed monitoring is disabled.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html
        '''
        result = self._values.get("detailed_monitoring")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def disable_api_termination(self) -> typing.Optional[builtins.bool]:
        '''If you set this parameter to true, you cannot terminate the instances launched with this launch template using the Amazon EC2 console, CLI, or API;

        otherwise, you can.

        :default: - The API termination setting is not specified in the Launch Template.
        '''
        result = self._values.get("disable_api_termination")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ebs_optimized(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether the instances are optimized for Amazon EBS I/O.

        This optimization provides dedicated throughput
        to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization
        isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance.

        :default: - EBS optimization is not specified in the launch template.
        '''
        result = self._values.get("ebs_optimized")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def hibernation_configured(self) -> typing.Optional[builtins.bool]:
        '''If you set this parameter to true, the instance is enabled for hibernation.

        :default: - Hibernation configuration is not specified in the launch template; defaulting to false.
        '''
        result = self._values.get("hibernation_configured")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_endpoint(self) -> typing.Optional[builtins.bool]:
        '''Enables or disables the HTTP metadata endpoint on your instances.

        :default: true

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpendpoint
        '''
        result = self._values.get("http_endpoint")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_protocol_ipv6(self) -> typing.Optional[builtins.bool]:
        '''Enables or disables the IPv6 endpoint for the instance metadata service.

        :default: true

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpprotocolipv6
        '''
        result = self._values.get("http_protocol_ipv6")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def http_put_response_hop_limit(self) -> typing.Optional[jsii.Number]:
        '''The desired HTTP PUT response hop limit for instance metadata requests.

        The larger the number, the further instance metadata requests can travel.

        :default: 1

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpputresponsehoplimit
        '''
        result = self._values.get("http_put_response_hop_limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def http_tokens(self) -> typing.Optional[LaunchTemplateHttpTokens]:
        '''The state of token usage for your instance metadata requests.

        The default state is ``optional`` if not specified. However,
        if requireImdsv2 is true, the state must be ``required``.

        :default: LaunchTemplateHttpTokens.OPTIONAL

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httptokens
        '''
        result = self._values.get("http_tokens")
        return typing.cast(typing.Optional[LaunchTemplateHttpTokens], result)

    @builtins.property
    def instance_initiated_shutdown_behavior(
        self,
    ) -> typing.Optional[InstanceInitiatedShutdownBehavior]:
        '''Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown).

        :default: - Shutdown behavior is not specified in the launch template; defaults to STOP.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior
        '''
        result = self._values.get("instance_initiated_shutdown_behavior")
        return typing.cast(typing.Optional[InstanceInitiatedShutdownBehavior], result)

    @builtins.property
    def instance_metadata_tags(self) -> typing.Optional[builtins.bool]:
        '''Set to enabled to allow access to instance tags from the instance metadata.

        Set to disabled to turn off access to instance tags from the instance metadata.

        :default: false

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-instancemetadatatags
        '''
        result = self._values.get("instance_metadata_tags")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def instance_profile(self) -> typing.Optional[_IInstanceProfile_10d5ce2c]:
        '''The instance profile used to pass role information to EC2 instances.

        Note: You can provide an instanceProfile or a role, but not both.

        :default: - No instance profile
        '''
        result = self._values.get("instance_profile")
        return typing.cast(typing.Optional[_IInstanceProfile_10d5ce2c], result)

    @builtins.property
    def instance_type(self) -> typing.Optional[InstanceType]:
        '''Type of instance to launch.

        :default: - This Launch Template does not specify a default Instance Type.
        '''
        result = self._values.get("instance_type")
        return typing.cast(typing.Optional[InstanceType], result)

    @builtins.property
    def key_name(self) -> typing.Optional[builtins.str]:
        '''(deprecated) Name of SSH keypair to grant access to instance.

        :default: - No SSH access will be possible.

        :deprecated: - Use ``keyPair`` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair

        :stability: deprecated
        '''
        result = self._values.get("key_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_pair(self) -> typing.Optional[IKeyPair]:
        '''The SSH keypair to grant access to the instance.

        :default: - No SSH access will be possible.
        '''
        result = self._values.get("key_pair")
        return typing.cast(typing.Optional[IKeyPair], result)

    @builtins.property
    def launch_template_name(self) -> typing.Optional[builtins.str]:
        '''Name for this launch template.

        :default: Automatically generated name
        '''
        result = self._values.get("launch_template_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def machine_image(self) -> typing.Optional[IMachineImage]:
        '''The AMI that will be used by instances.

        :default: - This Launch Template does not specify a default AMI.
        '''
        result = self._values.get("machine_image")
        return typing.cast(typing.Optional[IMachineImage], result)

    @builtins.property
    def nitro_enclave_enabled(self) -> typing.Optional[builtins.bool]:
        '''If this parameter is set to true, the instance is enabled for AWS Nitro Enclaves;

        otherwise, it is not enabled for AWS Nitro Enclaves.

        :default: - Enablement of Nitro enclaves is not specified in the launch template; defaulting to false.
        '''
        result = self._values.get("nitro_enclave_enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def require_imdsv2(self) -> typing.Optional[builtins.bool]:
        '''Whether IMDSv2 should be required on launched instances.

        :default: - false
        '''
        result = self._values.get("require_imdsv2")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def role(self) -> typing.Optional[_IRole_235f5d8e]:
        '''An IAM role to associate with the instance profile that is used by instances.

        The role must be assumable by the service principal ``ec2.amazonaws.com``.
        Note: You can provide an instanceProfile or a role, but not both.

        :default: - No new role is created.

        Example::

            role = iam.Role(self, "MyRole",
                assumed_by=iam.ServicePrincipal("ec2.amazonaws.com")
            )
        '''
        result = self._values.get("role")
        return typing.cast(typing.Optional[_IRole_235f5d8e], result)

    @builtins.property
    def security_group(self) -> typing.Optional[ISecurityGroup]:
        '''Security group to assign to instances created with the launch template.

        :default: No security group is assigned.
        '''
        result = self._values.get("security_group")
        return typing.cast(typing.Optional[ISecurityGroup], result)

    @builtins.property
    def spot_options(self) -> typing.Optional["LaunchTemplateSpotOptions"]:
        '''If this property is defined, then the Launch Template's InstanceMarketOptions will be set to use Spot instances, and the options for the Spot instances will be as defined.

        :default: - Instance launched with this template will not be spot instances.
        '''
        result = self._values.get("spot_options")
        return typing.cast(typing.Optional["LaunchTemplateSpotOptions"], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''The AMI that will be used by instances.

        :default:

        - This Launch Template creates a UserData based on the type of provided
        machineImage; no UserData is created if a machineImage is not provided
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LaunchTemplateProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_IAspect_118c810a)
class LaunchTemplateRequireImdsv2Aspect(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateRequireImdsv2Aspect",
):
    '''Aspect that applies IMDS configuration on EC2 Launch Template constructs.

    :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        launch_template_require_imdsv2_aspect = ec2.LaunchTemplateRequireImdsv2Aspect(
            suppress_warnings=False
        )
    '''

    def __init__(
        self,
        *,
        suppress_warnings: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param suppress_warnings: Whether warning annotations from this Aspect should be suppressed or not. Default: - false
        '''
        props = LaunchTemplateRequireImdsv2AspectProps(
            suppress_warnings=suppress_warnings
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="visit")
    def visit(self, node: _constructs_77d1e7e8.IConstruct) -> None:
        '''All aspects can visit an IConstruct.

        :param node: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5b55557b3575acd995d431b2ff6c8e2de0b98c65fba692635404794b841a612)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast(None, jsii.invoke(self, "visit", [node]))

    @jsii.member(jsii_name="warn")
    def _warn(
        self,
        node: _constructs_77d1e7e8.IConstruct,
        message: builtins.str,
    ) -> None:
        '''Adds a warning annotation to a node, unless ``suppressWarnings`` is true.

        :param node: The scope to add the warning to.
        :param message: The warning message.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4640c020d65b4f4b05a42f3460ae9f0e3e18831e06ee60bc381a819010d705df)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
            check_type(argname="argument message", value=message, expected_type=type_hints["message"])
        return typing.cast(None, jsii.invoke(self, "warn", [node, message]))

    @builtins.property
    @jsii.member(jsii_name="suppressWarnings")
    def _suppress_warnings(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "suppressWarnings"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateRequireImdsv2AspectProps",
    jsii_struct_bases=[],
    name_mapping={"suppress_warnings": "suppressWarnings"},
)
class LaunchTemplateRequireImdsv2AspectProps:
    def __init__(
        self,
        *,
        suppress_warnings: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Properties for ``LaunchTemplateRequireImdsv2Aspect``.

        :param suppress_warnings: Whether warning annotations from this Aspect should be suppressed or not. Default: - false

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            launch_template_require_imdsv2_aspect_props = ec2.LaunchTemplateRequireImdsv2AspectProps(
                suppress_warnings=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__461147557db2c4a085df02a1282204cc06509d5da8725adad11f3088fa4028c4)
            check_type(argname="argument suppress_warnings", value=suppress_warnings, expected_type=type_hints["suppress_warnings"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if suppress_warnings is not None:
            self._values["suppress_warnings"] = suppress_warnings

    @builtins.property
    def suppress_warnings(self) -> typing.Optional[builtins.bool]:
        '''Whether warning annotations from this Aspect should be suppressed or not.

        :default: - false
        '''
        result = self._values.get("suppress_warnings")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LaunchTemplateRequireImdsv2AspectProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LaunchTemplateSpecialVersions(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateSpecialVersions",
):
    '''A class that provides convenient access to special version tokens for LaunchTemplate versions.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        launch_template_special_versions = ec2.LaunchTemplateSpecialVersions()
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_VERSION")
    def DEFAULT_VERSION(cls) -> builtins.str:
        '''The special value that denotes that users of a Launch Template should reference the DEFAULT version of the template.'''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_VERSION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LATEST_VERSION")
    def LATEST_VERSION(cls) -> builtins.str:
        '''The special value that denotes that users of a Launch Template should reference the LATEST version of the template.'''
        return typing.cast(builtins.str, jsii.sget(cls, "LATEST_VERSION"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LaunchTemplateSpotOptions",
    jsii_struct_bases=[],
    name_mapping={
        "block_duration": "blockDuration",
        "interruption_behavior": "interruptionBehavior",
        "max_price": "maxPrice",
        "request_type": "requestType",
        "valid_until": "validUntil",
    },
)
class LaunchTemplateSpotOptions:
    def __init__(
        self,
        *,
        block_duration: typing.Optional[_Duration_4839e8c3] = None,
        interruption_behavior: typing.Optional["SpotInstanceInterruption"] = None,
        max_price: typing.Optional[jsii.Number] = None,
        request_type: typing.Optional["SpotRequestType"] = None,
        valid_until: typing.Optional[_Expiration_059d47d0] = None,
    ) -> None:
        '''Interface for the Spot market instance options provided in a LaunchTemplate.

        :param block_duration: Spot Instances with a defined duration (also known as Spot blocks) are designed not to be interrupted and will run continuously for the duration you select. You can use a duration of 1, 2, 3, 4, 5, or 6 hours. Default: Requested spot instances do not have a pre-defined duration.
        :param interruption_behavior: The behavior when a Spot Instance is interrupted. Default: Spot instances will terminate when interrupted.
        :param max_price: Maximum hourly price you're willing to pay for each Spot instance. The value is given in dollars. ex: 0.01 for 1 cent per hour, or 0.001 for one-tenth of a cent per hour. Default: Maximum hourly price will default to the on-demand price for the instance type.
        :param request_type: The Spot Instance request type. If you are using Spot Instances with an Auto Scaling group, use one-time requests, as the Amazon EC2 Auto Scaling service handles requesting new Spot Instances whenever the group is below its desired capacity. Default: One-time spot request.
        :param valid_until: The end date of the request. For a one-time request, the request remains active until all instances launch, the request is canceled, or this date is reached. If the request is persistent, it remains active until it is canceled or this date and time is reached. Default: The default end date is 7 days from the current date.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            
            # expiration: cdk.Expiration
            
            launch_template_spot_options = ec2.LaunchTemplateSpotOptions(
                block_duration=cdk.Duration.minutes(30),
                interruption_behavior=ec2.SpotInstanceInterruption.STOP,
                max_price=123,
                request_type=ec2.SpotRequestType.ONE_TIME,
                valid_until=expiration
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a206647f8fdf80ee3d33b9394f5f273e82fa737f25e6e0d66c3a66fea6392403)
            check_type(argname="argument block_duration", value=block_duration, expected_type=type_hints["block_duration"])
            check_type(argname="argument interruption_behavior", value=interruption_behavior, expected_type=type_hints["interruption_behavior"])
            check_type(argname="argument max_price", value=max_price, expected_type=type_hints["max_price"])
            check_type(argname="argument request_type", value=request_type, expected_type=type_hints["request_type"])
            check_type(argname="argument valid_until", value=valid_until, expected_type=type_hints["valid_until"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if block_duration is not None:
            self._values["block_duration"] = block_duration
        if interruption_behavior is not None:
            self._values["interruption_behavior"] = interruption_behavior
        if max_price is not None:
            self._values["max_price"] = max_price
        if request_type is not None:
            self._values["request_type"] = request_type
        if valid_until is not None:
            self._values["valid_until"] = valid_until

    @builtins.property
    def block_duration(self) -> typing.Optional[_Duration_4839e8c3]:
        '''Spot Instances with a defined duration (also known as Spot blocks) are designed not to be interrupted and will run continuously for the duration you select.

        You can use a duration of 1, 2, 3, 4, 5, or 6 hours.

        :default: Requested spot instances do not have a pre-defined duration.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances
        '''
        result = self._values.get("block_duration")
        return typing.cast(typing.Optional[_Duration_4839e8c3], result)

    @builtins.property
    def interruption_behavior(self) -> typing.Optional["SpotInstanceInterruption"]:
        '''The behavior when a Spot Instance is interrupted.

        :default: Spot instances will terminate when interrupted.
        '''
        result = self._values.get("interruption_behavior")
        return typing.cast(typing.Optional["SpotInstanceInterruption"], result)

    @builtins.property
    def max_price(self) -> typing.Optional[jsii.Number]:
        '''Maximum hourly price you're willing to pay for each Spot instance.

        The value is given
        in dollars. ex: 0.01 for 1 cent per hour, or 0.001 for one-tenth of a cent per hour.

        :default: Maximum hourly price will default to the on-demand price for the instance type.
        '''
        result = self._values.get("max_price")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def request_type(self) -> typing.Optional["SpotRequestType"]:
        '''The Spot Instance request type.

        If you are using Spot Instances with an Auto Scaling group, use one-time requests, as the
        Amazon EC2 Auto Scaling service handles requesting new Spot Instances whenever the group is
        below its desired capacity.

        :default: One-time spot request.
        '''
        result = self._values.get("request_type")
        return typing.cast(typing.Optional["SpotRequestType"], result)

    @builtins.property
    def valid_until(self) -> typing.Optional[_Expiration_059d47d0]:
        '''The end date of the request.

        For a one-time request, the request remains active until all instances
        launch, the request is canceled, or this date is reached. If the request is persistent, it remains
        active until it is canceled or this date and time is reached.

        :default: The default end date is 7 days from the current date.
        '''
        result = self._values.get("valid_until")
        return typing.cast(typing.Optional[_Expiration_059d47d0], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LaunchTemplateSpotOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LinuxUserDataOptions",
    jsii_struct_bases=[],
    name_mapping={"shebang": "shebang"},
)
class LinuxUserDataOptions:
    def __init__(self, *, shebang: typing.Optional[builtins.str] = None) -> None:
        '''Options when constructing UserData for Linux.

        :param shebang: Shebang for the UserData script. Default: "#!/bin/bash"

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            linux_user_data_options = ec2.LinuxUserDataOptions(
                shebang="shebang"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2127959dc053a2a795f9980d0ae63fe2060820b5ef07942b1a760aea504d4441)
            check_type(argname="argument shebang", value=shebang, expected_type=type_hints["shebang"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if shebang is not None:
            self._values["shebang"] = shebang

    @builtins.property
    def shebang(self) -> typing.Optional[builtins.str]:
        '''Shebang for the UserData script.

        :default: "#!/bin/bash"
        '''
        result = self._values.get("shebang")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LinuxUserDataOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LocationPackageOptions",
    jsii_struct_bases=[],
    name_mapping={"key": "key", "service_restart_handles": "serviceRestartHandles"},
)
class LocationPackageOptions:
    def __init__(
        self,
        *,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    ) -> None:
        '''Options for InitPackage.rpm/InitPackage.msi.

        :param key: Identifier key for this package. You can use this to order package installs. Default: - Automatically generated
        :param service_restart_handles: Restart the given service after this command has run. Default: - Do not restart any service

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # init_service_restart_handle: ec2.InitServiceRestartHandle
            
            location_package_options = ec2.LocationPackageOptions(
                key="key",
                service_restart_handles=[init_service_restart_handle]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__adb9aead901a9e42e17ecf53f0a66db93e64d4cc2e633a62de1a847f4c40aa01)
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if key is not None:
            self._values["key"] = key
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles

    @builtins.property
    def key(self) -> typing.Optional[builtins.str]:
        '''Identifier key for this package.

        You can use this to order package installs.

        :default: - Automatically generated
        '''
        result = self._values.get("key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List[InitServiceRestartHandle]]:
        '''Restart the given service after this command has run.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List[InitServiceRestartHandle]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LocationPackageOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LogFormat(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.LogFormat"):
    '''The following table describes all of the available fields for a flow log record.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "Vpc")
        
        vpc.add_flow_log("FlowLog",
            log_format=[ec2.LogFormat.DST_PORT, ec2.LogFormat.SRC_PORT
            ]
        )
        
        # If you just want to add a field to the default field
        vpc.add_flow_log("FlowLog",
            log_format=[ec2.LogFormat.VERSION, ec2.LogFormat.ALL_DEFAULT_FIELDS
            ]
        )
        
        # If AWS CDK does not support the new fields
        vpc.add_flow_log("FlowLog",
            log_format=[ec2.LogFormat.SRC_PORT,
                ec2.LogFormat.custom("${new-field}")
            ]
        )
    '''

    def __init__(self, value: builtins.str) -> None:
        '''
        :param value: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1c5c6c6cc89dffe7c8eddee547516c93284e5aac407878167afdf814ec7d9ade)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.create(self.__class__, self, [value])

    @jsii.member(jsii_name="custom")
    @builtins.classmethod
    def custom(cls, format_string: builtins.str) -> "LogFormat":
        '''A custom format string.

        Gives full control over the format string fragment.

        :param format_string: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__116b2796c8db85d0aa8841c90870e7987ae492826d4ef5cab5a84cc6d0d154fb)
            check_type(argname="argument format_string", value=format_string, expected_type=type_hints["format_string"])
        return typing.cast("LogFormat", jsii.sinvoke(cls, "custom", [format_string]))

    @jsii.member(jsii_name="field")
    @builtins.classmethod
    def field(cls, field: builtins.str) -> "LogFormat":
        '''A custom field name.

        If there is no ready-made constant for a new field yet, you can use this.
        The field name will automatically be wrapped in ``${ ... }``.

        :param field: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53a4a0b5f512af6dba8bc863e21b62304942117a36741bb04e639515b3195296)
            check_type(argname="argument field", value=field, expected_type=type_hints["field"])
        return typing.cast("LogFormat", jsii.sinvoke(cls, "field", [field]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ACCOUNT_ID")
    def ACCOUNT_ID(cls) -> "LogFormat":
        '''The AWS account ID of the owner of the source network interface for which traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "ACCOUNT_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ACTION")
    def ACTION(cls) -> "LogFormat":
        '''The action that is associated with the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "ACTION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ALL_DEFAULT_FIELDS")
    def ALL_DEFAULT_FIELDS(cls) -> "LogFormat":
        '''The default format.'''
        return typing.cast("LogFormat", jsii.sget(cls, "ALL_DEFAULT_FIELDS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="AZ_ID")
    def AZ_ID(cls) -> "LogFormat":
        '''The ID of the Availability Zone that contains the network interface for which traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "AZ_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="BYTES")
    def BYTES(cls) -> "LogFormat":
        '''The number of bytes transferred during the flow.'''
        return typing.cast("LogFormat", jsii.sget(cls, "BYTES"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DST_ADDR")
    def DST_ADDR(cls) -> "LogFormat":
        '''The destination address for outgoing traffic, or the IPv4 or IPv6 address of the network interface for incoming traffic on the network interface.'''
        return typing.cast("LogFormat", jsii.sget(cls, "DST_ADDR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DST_PORT")
    def DST_PORT(cls) -> "LogFormat":
        '''The destination port of the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "DST_PORT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="END_TIMESTAMP")
    def END_TIMESTAMP(cls) -> "LogFormat":
        '''The time, in Unix seconds, when the last packet of the flow was received within the aggregation interval.

        This might be up to 60 seconds after the packet was transmitted or received on
        the network interface.
        '''
        return typing.cast("LogFormat", jsii.sget(cls, "END_TIMESTAMP"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="FLOW_DIRECTION")
    def FLOW_DIRECTION(cls) -> "LogFormat":
        '''The direction of the flow with respect to the interface where traffic is captured.'''
        return typing.cast("LogFormat", jsii.sget(cls, "FLOW_DIRECTION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="INSTANCE_ID")
    def INSTANCE_ID(cls) -> "LogFormat":
        '''The ID of the instance that's associated with network interface for which the traffic is recorded, if the instance is owned by you.

        Returns a '-' symbol for a requester-managed network interface; for example, the
        network interface for a NAT gateway
        '''
        return typing.cast("LogFormat", jsii.sget(cls, "INSTANCE_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="INTERFACE_ID")
    def INTERFACE_ID(cls) -> "LogFormat":
        '''The ID of the network interface for which the traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "INTERFACE_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="LOG_STATUS")
    def LOG_STATUS(cls) -> "LogFormat":
        '''The logging status of the flow log.'''
        return typing.cast("LogFormat", jsii.sget(cls, "LOG_STATUS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PACKETS")
    def PACKETS(cls) -> "LogFormat":
        '''The number of packets transferred during the flow.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PACKETS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PKT_DST_ADDR")
    def PKT_DST_ADDR(cls) -> "LogFormat":
        '''The packet-level (original) destination IP address for the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PKT_DST_ADDR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PKT_DST_AWS_SERVICE")
    def PKT_DST_AWS_SERVICE(cls) -> "LogFormat":
        '''The name of the subset of IP address ranges for the pkt-dstaddr field, if the destination IP address is for an AWS service.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PKT_DST_AWS_SERVICE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PKT_SRC_ADDR")
    def PKT_SRC_ADDR(cls) -> "LogFormat":
        '''The packet-level (original) source IP address of the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PKT_SRC_ADDR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PKT_SRC_AWS_SERVICE")
    def PKT_SRC_AWS_SERVICE(cls) -> "LogFormat":
        '''The name of the subset of IP address ranges for the pkt-srcaddr field, if the source IP address is for an AWS service.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PKT_SRC_AWS_SERVICE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PROTOCOL")
    def PROTOCOL(cls) -> "LogFormat":
        '''The IANA protocol number of the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "PROTOCOL"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="REGION")
    def REGION(cls) -> "LogFormat":
        '''The Region that contains the network interface for which traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "REGION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SRC_ADDR")
    def SRC_ADDR(cls) -> "LogFormat":
        '''The source address for incoming traffic, or the IPv4 or IPv6 address of the network interface for outgoing traffic on the network interface.'''
        return typing.cast("LogFormat", jsii.sget(cls, "SRC_ADDR"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SRC_PORT")
    def SRC_PORT(cls) -> "LogFormat":
        '''The source port of the traffic.'''
        return typing.cast("LogFormat", jsii.sget(cls, "SRC_PORT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="START_TIMESTAMP")
    def START_TIMESTAMP(cls) -> "LogFormat":
        '''The time, in Unix seconds, when the first packet of the flow was received within the aggregation interval.

        This might be up to 60 seconds after the packet was transmitted or received on
        the network interface.
        '''
        return typing.cast("LogFormat", jsii.sget(cls, "START_TIMESTAMP"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SUBLOCATION_ID")
    def SUBLOCATION_ID(cls) -> "LogFormat":
        '''The ID of the sublocation that contains the network interface for which traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "SUBLOCATION_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SUBLOCATION_TYPE")
    def SUBLOCATION_TYPE(cls) -> "LogFormat":
        '''The type of sublocation that's returned in the sublocation-id field.'''
        return typing.cast("LogFormat", jsii.sget(cls, "SUBLOCATION_TYPE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SUBNET_ID")
    def SUBNET_ID(cls) -> "LogFormat":
        '''The ID of the subnet that contains the network interface for which the traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "SUBNET_ID"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TCP_FLAGS")
    def TCP_FLAGS(cls) -> "LogFormat":
        '''The bitmask value for TCP flags.

        - FIN -- 1
        - SYN -- 2
        - RST -- 4
        - SYN-ACK -- 18

        If no supported flags are recorded, the TCP flag value is 0.

        TCP flags can be OR-ed during the aggregation interval. For short connections,
        the flags might be set on the same line in the flow log record, for example,
        19 for SYN-ACK and FIN, and 3 for SYN and FIN.
        '''
        return typing.cast("LogFormat", jsii.sget(cls, "TCP_FLAGS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRAFFIC_PATH")
    def TRAFFIC_PATH(cls) -> "LogFormat":
        '''The path that egress traffic takes to the destination.'''
        return typing.cast("LogFormat", jsii.sget(cls, "TRAFFIC_PATH"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="TRAFFIC_TYPE")
    def TRAFFIC_TYPE(cls) -> "LogFormat":
        '''The type of traffic.

        The possible values are IPv4, IPv6, or EFA.
        '''
        return typing.cast("LogFormat", jsii.sget(cls, "TRAFFIC_TYPE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="VERSION")
    def VERSION(cls) -> "LogFormat":
        '''The VPC Flow Logs version.'''
        return typing.cast("LogFormat", jsii.sget(cls, "VERSION"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="VPC_ID")
    def VPC_ID(cls) -> "LogFormat":
        '''The ID of the VPC that contains the network interface for which the traffic is recorded.'''
        return typing.cast("LogFormat", jsii.sget(cls, "VPC_ID"))

    @builtins.property
    @jsii.member(jsii_name="value")
    def value(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "value"))


@jsii.implements(IMachineImage)
class LookupMachineImage(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.LookupMachineImage",
):
    '''A machine image whose AMI ID will be searched using DescribeImages.

    The most recent, available, launchable image matching the given filter
    criteria will be used. Looking up AMIs may take a long time; specify
    as many filter criteria as possible to narrow down the search.

    The AMI selected will be cached in ``cdk.context.json`` and the same value
    will be used on future runs. To refresh the AMI lookup, you will have to
    evict the value from the cache using the ``cdk context`` command. See
    https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # user_data: ec2.UserData
        
        lookup_machine_image = ec2.LookupMachineImage(
            name="name",
        
            # the properties below are optional
            filters={
                "filters_key": ["filters"]
            },
            owners=["owners"],
            user_data=user_data,
            windows=False
        )
    '''

    def __init__(
        self,
        *,
        name: builtins.str,
        filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
        owners: typing.Optional[typing.Sequence[builtins.str]] = None,
        user_data: typing.Optional["UserData"] = None,
        windows: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param name: Name of the image (may contain wildcards).
        :param filters: Additional filters on the AMI. Default: - No additional filters
        :param owners: Owner account IDs or aliases. Default: - All owners
        :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
        :param windows: Look for Windows images. Default: false
        '''
        props = LookupMachineImageProps(
            name=name,
            filters=filters,
            owners=owners,
            user_data=user_data,
            windows=windows,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> "MachineImageConfig":
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__866a74bec8e14dd27073a82d4ff7b25ab450e0eff08b7026d084319984dfb12c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("MachineImageConfig", jsii.invoke(self, "getImage", [scope]))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.LookupMachineImageProps",
    jsii_struct_bases=[],
    name_mapping={
        "name": "name",
        "filters": "filters",
        "owners": "owners",
        "user_data": "userData",
        "windows": "windows",
    },
)
class LookupMachineImageProps:
    def __init__(
        self,
        *,
        name: builtins.str,
        filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
        owners: typing.Optional[typing.Sequence[builtins.str]] = None,
        user_data: typing.Optional["UserData"] = None,
        windows: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Properties for looking up an image.

        :param name: Name of the image (may contain wildcards).
        :param filters: Additional filters on the AMI. Default: - No additional filters
        :param owners: Owner account IDs or aliases. Default: - All owners
        :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
        :param windows: Look for Windows images. Default: false

        :exampleMetadata: lit=aws-ec2/test/example.images.lit.ts infused

        Example::

            # Pick the right Amazon Linux edition. All arguments shown are optional
            # and will default to these values when omitted.
            amzn_linux = ec2.MachineImage.latest_amazon_linux(
                generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
                edition=ec2.AmazonLinuxEdition.STANDARD,
                virtualization=ec2.AmazonLinuxVirt.HVM,
                storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE,
                cpu_type=ec2.AmazonLinuxCpuType.X86_64
            )
            
            # Pick a Windows edition to use
            windows = ec2.MachineImage.latest_windows(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
            
            # Read AMI id from SSM parameter store
            ssm = ec2.MachineImage.from_ssm_parameter("/my/ami", os=ec2.OperatingSystemType.LINUX)
            
            # Look up the most recent image matching a set of AMI filters.
            # In this case, look up the NAT instance AMI, by using a wildcard
            # in the 'name' field:
            nat_ami = ec2.MachineImage.lookup(
                name="amzn-ami-vpc-nat-*",
                owners=["amazon"]
            )
            
            # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
            # a map giving the AMI to in for each region:
            linux = ec2.MachineImage.generic_linux({
                "us-east-1": "ami-97785bed",
                "eu-west-1": "ami-12345678"
            })
            
            # For other custom (Windows) images, instantiate a `GenericWindowsImage` with
            # a map giving the AMI to in for each region:
            generic_windows = ec2.MachineImage.generic_windows({
                "us-east-1": "ami-97785bed",
                "eu-west-1": "ami-12345678"
            })
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c44b2bd75c4714250889165d6fd2d06ab6a906b90c817320a7c5f526dcbfc2f)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
            check_type(argname="argument owners", value=owners, expected_type=type_hints["owners"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument windows", value=windows, expected_type=type_hints["windows"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "name": name,
        }
        if filters is not None:
            self._values["filters"] = filters
        if owners is not None:
            self._values["owners"] = owners
        if user_data is not None:
            self._values["user_data"] = user_data
        if windows is not None:
            self._values["windows"] = windows

    @builtins.property
    def name(self) -> builtins.str:
        '''Name of the image (may contain wildcards).'''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def filters(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.List[builtins.str]]]:
        '''Additional filters on the AMI.

        :default: - No additional filters

        :see: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html
        '''
        result = self._values.get("filters")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.List[builtins.str]]], result)

    @builtins.property
    def owners(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Owner account IDs or aliases.

        :default: - All owners
        '''
        result = self._values.get("owners")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Custom userdata for this image.

        :default: - Empty user data appropriate for the platform type
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    @builtins.property
    def windows(self) -> typing.Optional[builtins.bool]:
        '''Look for Windows images.

        :default: false
        '''
        result = self._values.get("windows")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LookupMachineImageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MachineImage(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.MachineImage",
):
    '''Factory functions for standard Amazon Machine Image objects.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        my_security_group = ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)
        autoscaling.AutoScalingGroup(self, "ASG",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE2, ec2.InstanceSize.MICRO),
            machine_image=ec2.MachineImage.latest_amazon_linux2(),
            security_group=my_security_group
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromSsmParameter")
    @builtins.classmethod
    def from_ssm_parameter(
        cls,
        parameter_name: builtins.str,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        os: typing.Optional["OperatingSystemType"] = None,
        parameter_version: typing.Optional[builtins.str] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''An image specified in SSM parameter store.

        By default, the SSM parameter is refreshed at every deployment,
        causing your instances to be replaced whenever a new version of the AMI
        is released.

        Pass ``{ cachedInContext: true }`` to keep the AMI ID stable. If you do, you
        will have to remember to periodically invalidate the context to refresh
        to the newest AMI ID.

        :param parameter_name: -
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param os: Operating system. Default: OperatingSystemType.LINUX
        :param parameter_version: The version of the SSM parameter. Default: no version specified.
        :param user_data: Custom UserData. Default: - UserData appropriate for the OS
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__677afd5ea9b4639913a489ab67346107c0d290e015be12483e980d3a19e33a6e)
            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
        options = SsmParameterImageOptions(
            cached_in_context=cached_in_context,
            os=os,
            parameter_version=parameter_version,
            user_data=user_data,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "fromSsmParameter", [parameter_name, options]))

    @jsii.member(jsii_name="genericLinux")
    @builtins.classmethod
    def generic_linux(
        cls,
        ami_map: typing.Mapping[builtins.str, builtins.str],
        *,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''A Linux image where you specify the AMI ID for every region.

        :param ami_map: For every region where you are deploying the stack, specify the AMI ID for that region.
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d714de85d2e270ff2ba41661578c069d4eb1590eb5a816cd8ad1800ea2f837db)
            check_type(argname="argument ami_map", value=ami_map, expected_type=type_hints["ami_map"])
        props = GenericLinuxImageProps(user_data=user_data)

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "genericLinux", [ami_map, props]))

    @jsii.member(jsii_name="genericWindows")
    @builtins.classmethod
    def generic_windows(
        cls,
        ami_map: typing.Mapping[builtins.str, builtins.str],
        *,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''A Windows image where you specify the AMI ID for every region.

        :param ami_map: For every region where you are deploying the stack, specify the AMI ID for that region.
        :param user_data: Initial user data. Default: - Empty UserData for Windows machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__392190b85391a62926181097d2a921287a636c9c89ceeb2eb0894b5401830373)
            check_type(argname="argument ami_map", value=ami_map, expected_type=type_hints["ami_map"])
        props = GenericWindowsImageProps(user_data=user_data)

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "genericWindows", [ami_map, props]))

    @jsii.member(jsii_name="latestAmazonLinux")
    @builtins.classmethod
    def latest_amazon_linux(
        cls,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        generation: typing.Optional[AmazonLinuxGeneration] = None,
        kernel: typing.Optional[AmazonLinuxKernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        user_data: typing.Optional["UserData"] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
    ) -> IMachineImage:
        '''(deprecated) An Amazon Linux image that is automatically kept up-to-date.

        This Machine Image automatically updates to the latest version on every
        deployment. Be aware this will cause your instances to be replaced when a
        new version of the image becomes available. Do not store stateful information
        on the instance if you are using this image.

        N.B.: "latest" in the name of this function indicates that it always uses the most recent
        image of a particular generation of Amazon Linux, not that it uses the "latest generation".
        For backwards compatibility, this function uses Amazon Linux 1 if no generation
        is specified.

        Specify the desired generation using the ``generation`` property::

           ec2.MachineImage.latest_amazon_linux(
               # Use Amazon Linux 2
               generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2
           )

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param cpu_type: CPU Type. Default: X86_64
        :param edition: What edition of Amazon Linux to use. Default: Standard
        :param generation: What generation of Amazon Linux to use. Default: AmazonLinux
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param virtualization: Virtualization type. Default: HVM

        :deprecated: use MachineImage.latestAmazonLinux2 instead

        :stability: deprecated
        '''
        props = AmazonLinuxImageProps(
            cached_in_context=cached_in_context,
            cpu_type=cpu_type,
            edition=edition,
            generation=generation,
            kernel=kernel,
            storage=storage,
            user_data=user_data,
            virtualization=virtualization,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "latestAmazonLinux", [props]))

    @jsii.member(jsii_name="latestAmazonLinux2")
    @builtins.classmethod
    def latest_amazon_linux2(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2Kernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''An Amazon Linux 2 image that is automatically kept up-to-date.

        This Machine Image automatically updates to the latest version on every
        deployment. Be aware this will cause your instances to be replaced when a
        new version of the image becomes available. Do not store stateful information
        on the instance if you are using this image.

        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param virtualization: Virtualization type. Default: HVM
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2ImageSsmParameterProps(
            kernel=kernel,
            storage=storage,
            virtualization=virtualization,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "latestAmazonLinux2", [props]))

    @jsii.member(jsii_name="latestAmazonLinux2022")
    @builtins.classmethod
    def latest_amazon_linux2022(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2022Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''(deprecated) An Amazon Linux 2022 image that is automatically kept up-to-date.

        This Machine Image automatically updates to the latest version on every
        deployment. Be aware this will cause your instances to be replaced when a
        new version of the image becomes available. Do not store stateful information
        on the instance if you are using this image.

        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines

        :deprecated: - use latestAmazonLinux2023() instead

        :stability: deprecated
        '''
        props = AmazonLinux2022ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "latestAmazonLinux2022", [props]))

    @jsii.member(jsii_name="latestAmazonLinux2023")
    @builtins.classmethod
    def latest_amazon_linux2023(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2023Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''An Amazon Linux 2023 image that is automatically kept up-to-date.

        This Machine Image automatically updates to the latest version on every
        deployment. Be aware this will cause your instances to be replaced when a
        new version of the image becomes available. Do not store stateful information
        on the instance if you are using this image.

        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2023ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "latestAmazonLinux2023", [props]))

    @jsii.member(jsii_name="latestWindows")
    @builtins.classmethod
    def latest_windows(
        cls,
        version: "WindowsVersion",
        *,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''A Windows image that is automatically kept up-to-date.

        This Machine Image automatically updates to the latest version on every
        deployment. Be aware this will cause your instances to be replaced when a
        new version of the image becomes available. Do not store stateful information
        on the instance if you are using this image.

        :param version: -
        :param user_data: Initial user data. Default: - Empty UserData for Windows machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0340fbf48f206279d16bd5e5e0956522ca9a19ba8d39aa2efcc7d06b4f130f7c)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        props = WindowsImageProps(user_data=user_data)

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "latestWindows", [version, props]))

    @jsii.member(jsii_name="lookup")
    @builtins.classmethod
    def lookup(
        cls,
        *,
        name: builtins.str,
        filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
        owners: typing.Optional[typing.Sequence[builtins.str]] = None,
        user_data: typing.Optional["UserData"] = None,
        windows: typing.Optional[builtins.bool] = None,
    ) -> IMachineImage:
        '''Look up a shared Machine Image using DescribeImages.

        The most recent, available, launchable image matching the given filter
        criteria will be used. Looking up AMIs may take a long time; specify
        as many filter criteria as possible to narrow down the search.

        The AMI selected will be cached in ``cdk.context.json`` and the same value
        will be used on future runs. To refresh the AMI lookup, you will have to
        evict the value from the cache using the ``cdk context`` command. See
        https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.

        This function can not be used in environment-agnostic stacks.

        :param name: Name of the image (may contain wildcards).
        :param filters: Additional filters on the AMI. Default: - No additional filters
        :param owners: Owner account IDs or aliases. Default: - All owners
        :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
        :param windows: Look for Windows images. Default: false
        '''
        props = LookupMachineImageProps(
            name=name,
            filters=filters,
            owners=owners,
            user_data=user_data,
            windows=windows,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "lookup", [props]))

    @jsii.member(jsii_name="resolveSsmParameterAtLaunch")
    @builtins.classmethod
    def resolve_ssm_parameter_at_launch(
        cls,
        parameter_name: builtins.str,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        os: typing.Optional["OperatingSystemType"] = None,
        parameter_version: typing.Optional[builtins.str] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> IMachineImage:
        '''An image specified in SSM parameter store that will be resolved at instance launch time.

        The AMI ID will be resolved at instance launch time.

        :param parameter_name: The name of SSM parameter containing the AMI ID.
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param os: Operating system. Default: OperatingSystemType.LINUX
        :param parameter_version: The version of the SSM parameter. Default: no version specified.
        :param user_data: Custom UserData. Default: - UserData appropriate for the OS

        :see: https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e832dd82a3ef447ebf9a639dc9d6983793ce7321287fb2370dbed898b67d02a)
            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
        options = SsmParameterImageOptions(
            cached_in_context=cached_in_context,
            os=os,
            parameter_version=parameter_version,
            user_data=user_data,
        )

        return typing.cast(IMachineImage, jsii.sinvoke(cls, "resolveSsmParameterAtLaunch", [parameter_name, options]))


class _MachineImageProxy(MachineImage):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, MachineImage).__jsii_proxy_class__ = lambda : _MachineImageProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.MachineImageConfig",
    jsii_struct_bases=[],
    name_mapping={"image_id": "imageId", "os_type": "osType", "user_data": "userData"},
)
class MachineImageConfig:
    def __init__(
        self,
        *,
        image_id: builtins.str,
        os_type: "OperatingSystemType",
        user_data: "UserData",
    ) -> None:
        '''Configuration for a machine image.

        :param image_id: The AMI ID of the image to use.
        :param os_type: Operating system type for this image.
        :param user_data: Initial UserData for this image.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            machine_image_config = ec2.MachineImageConfig(
                image_id="imageId",
                os_type=ec2.OperatingSystemType.LINUX,
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7f17ef82ffed569e1d3eda15e99a047a5e9d8b0481590a53a25125d7f1fd7b79)
            check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
            check_type(argname="argument os_type", value=os_type, expected_type=type_hints["os_type"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "image_id": image_id,
            "os_type": os_type,
            "user_data": user_data,
        }

    @builtins.property
    def image_id(self) -> builtins.str:
        '''The AMI ID of the image to use.'''
        result = self._values.get("image_id")
        assert result is not None, "Required property 'image_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def os_type(self) -> "OperatingSystemType":
        '''Operating system type for this image.'''
        result = self._values.get("os_type")
        assert result is not None, "Required property 'os_type' is missing"
        return typing.cast("OperatingSystemType", result)

    @builtins.property
    def user_data(self) -> "UserData":
        '''Initial UserData for this image.'''
        result = self._values.get("user_data")
        assert result is not None, "Required property 'user_data' is missing"
        return typing.cast("UserData", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MachineImageConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class MultipartBody(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.MultipartBody",
):
    '''The base class for all classes which can be used as ``MultipartUserData``.

    :exampleMetadata: infused

    Example::

        multipart_user_data = ec2.MultipartUserData()
        commands_user_data = ec2.UserData.for_linux()
        multipart_user_data.add_user_data_part(commands_user_data, ec2.MultipartBody.SHELL_SCRIPT, True)
        
        # Adding commands to the multipartUserData adds them to commandsUserData, and vice-versa.
        multipart_user_data.add_commands("touch /root/multi.txt")
        commands_user_data.add_commands("touch /root/userdata.txt")
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromRawBody")
    @builtins.classmethod
    def from_raw_body(
        cls,
        *,
        content_type: builtins.str,
        body: typing.Optional[builtins.str] = None,
        transfer_encoding: typing.Optional[builtins.str] = None,
    ) -> "MultipartBody":
        '''Constructs the raw ``MultipartBody`` using specified body, content type and transfer encoding.

        When transfer encoding is specified (typically as Base64), it's caller responsibility to convert body to
        Base64 either by wrapping with ``Fn.base64`` or by converting it by other converters.

        :param content_type: ``Content-Type`` header of this part. Some examples of content types: - ``text/x-shellscript; charset="utf-8"`` (shell script) - ``text/cloud-boothook; charset="utf-8"`` (shell script executed during boot phase) For Linux shell scripts use ``text/x-shellscript``.
        :param body: The body of message. Default: undefined - body will not be added to part
        :param transfer_encoding: ``Content-Transfer-Encoding`` header specifying part encoding. Default: undefined - body is not encoded
        '''
        opts = MultipartBodyOptions(
            content_type=content_type, body=body, transfer_encoding=transfer_encoding
        )

        return typing.cast("MultipartBody", jsii.sinvoke(cls, "fromRawBody", [opts]))

    @jsii.member(jsii_name="fromUserData")
    @builtins.classmethod
    def from_user_data(
        cls,
        user_data: "UserData",
        content_type: typing.Optional[builtins.str] = None,
    ) -> "MultipartBody":
        '''Constructs the new ``MultipartBody`` wrapping existing ``UserData``. Modification to ``UserData`` are reflected in subsequent renders of the part.

        For more information about content types see ``MultipartBodyOptions.contentType``.

        :param user_data: user data to wrap into body part.
        :param content_type: optional content type, if default one should not be used.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4bcf5944bbf508c594d36bed8323ce62fc0d344d2e371da577833926eaa6822a)
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
        return typing.cast("MultipartBody", jsii.sinvoke(cls, "fromUserData", [user_data, content_type]))

    @jsii.member(jsii_name="renderBodyPart")
    @abc.abstractmethod
    def render_body_part(self) -> typing.List[builtins.str]:
        '''Render body part as the string.

        Subclasses should not add leading nor trailing new line characters (\\r \\n)
        '''
        ...

    @jsii.python.classproperty
    @jsii.member(jsii_name="CLOUD_BOOTHOOK")
    def CLOUD_BOOTHOOK(cls) -> builtins.str:
        '''Content type for boot hooks.'''
        return typing.cast(builtins.str, jsii.sget(cls, "CLOUD_BOOTHOOK"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="SHELL_SCRIPT")
    def SHELL_SCRIPT(cls) -> builtins.str:
        '''Content type for shell scripts.'''
        return typing.cast(builtins.str, jsii.sget(cls, "SHELL_SCRIPT"))


class _MultipartBodyProxy(MultipartBody):
    @jsii.member(jsii_name="renderBodyPart")
    def render_body_part(self) -> typing.List[builtins.str]:
        '''Render body part as the string.

        Subclasses should not add leading nor trailing new line characters (\\r \\n)
        '''
        return typing.cast(typing.List[builtins.str], jsii.invoke(self, "renderBodyPart", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, MultipartBody).__jsii_proxy_class__ = lambda : _MultipartBodyProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.MultipartBodyOptions",
    jsii_struct_bases=[],
    name_mapping={
        "content_type": "contentType",
        "body": "body",
        "transfer_encoding": "transferEncoding",
    },
)
class MultipartBodyOptions:
    def __init__(
        self,
        *,
        content_type: builtins.str,
        body: typing.Optional[builtins.str] = None,
        transfer_encoding: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options when creating ``MultipartBody``.

        :param content_type: ``Content-Type`` header of this part. Some examples of content types: - ``text/x-shellscript; charset="utf-8"`` (shell script) - ``text/cloud-boothook; charset="utf-8"`` (shell script executed during boot phase) For Linux shell scripts use ``text/x-shellscript``.
        :param body: The body of message. Default: undefined - body will not be added to part
        :param transfer_encoding: ``Content-Transfer-Encoding`` header specifying part encoding. Default: undefined - body is not encoded

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            multipart_body_options = ec2.MultipartBodyOptions(
                content_type="contentType",
            
                # the properties below are optional
                body="body",
                transfer_encoding="transferEncoding"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aab871ef93c0eb481ccb98fb7b5dd3fcea8e991b8366d72ad818b3c7d9f946c5)
            check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
            check_type(argname="argument body", value=body, expected_type=type_hints["body"])
            check_type(argname="argument transfer_encoding", value=transfer_encoding, expected_type=type_hints["transfer_encoding"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "content_type": content_type,
        }
        if body is not None:
            self._values["body"] = body
        if transfer_encoding is not None:
            self._values["transfer_encoding"] = transfer_encoding

    @builtins.property
    def content_type(self) -> builtins.str:
        '''``Content-Type`` header of this part.

        Some examples of content types:

        - ``text/x-shellscript; charset="utf-8"`` (shell script)
        - ``text/cloud-boothook; charset="utf-8"`` (shell script executed during boot phase)

        For Linux shell scripts use ``text/x-shellscript``.
        '''
        result = self._values.get("content_type")
        assert result is not None, "Required property 'content_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def body(self) -> typing.Optional[builtins.str]:
        '''The body of message.

        :default: undefined - body will not be added to part
        '''
        result = self._values.get("body")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def transfer_encoding(self) -> typing.Optional[builtins.str]:
        '''``Content-Transfer-Encoding`` header specifying part encoding.

        :default: undefined - body is not encoded
        '''
        result = self._values.get("transfer_encoding")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MultipartBodyOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.MultipartUserDataOptions",
    jsii_struct_bases=[],
    name_mapping={"parts_separator": "partsSeparator"},
)
class MultipartUserDataOptions:
    def __init__(
        self,
        *,
        parts_separator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options for creating ``MultipartUserData``.

        :param parts_separator: The string used to separate parts in multipart user data archive (it's like MIME boundary). This string should contain [a-zA-Z0-9()+,-./:=?] characters only, and should not be present in any part, or in text content of archive. Default: ``+AWS+CDK+User+Data+Separator==``

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            multipart_user_data_options = ec2.MultipartUserDataOptions(
                parts_separator="partsSeparator"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a6cbd65538d4ad6bc35a85d0e1a054fa3cc215fdb97e33980478405a543ba7f)
            check_type(argname="argument parts_separator", value=parts_separator, expected_type=type_hints["parts_separator"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if parts_separator is not None:
            self._values["parts_separator"] = parts_separator

    @builtins.property
    def parts_separator(self) -> typing.Optional[builtins.str]:
        '''The string used to separate parts in multipart user data archive (it's like MIME boundary).

        This string should contain [a-zA-Z0-9()+,-./:=?] characters only, and should not be present in any part, or in text content of archive.

        :default: ``+AWS+CDK+User+Data+Separator==``
        '''
        result = self._values.get("parts_separator")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "MultipartUserDataOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.NamedPackageOptions",
    jsii_struct_bases=[],
    name_mapping={
        "service_restart_handles": "serviceRestartHandles",
        "version": "version",
    },
)
class NamedPackageOptions:
    def __init__(
        self,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        version: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''Options for InitPackage.yum/apt/rubyGem/python.

        :param service_restart_handles: Restart the given services after this command has run. Default: - Do not restart any service
        :param version: Specify the versions to install. Default: - Install the latest version

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # init_service_restart_handle: ec2.InitServiceRestartHandle
            
            named_package_options = ec2.NamedPackageOptions(
                service_restart_handles=[init_service_restart_handle],
                version=["version"]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2c1639fe59f604f4ab481f24912927ecf8af3c8a8827e677c9cac8d8b679f6b8)
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles
        if version is not None:
            self._values["version"] = version

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List[InitServiceRestartHandle]]:
        '''Restart the given services after this command has run.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List[InitServiceRestartHandle]], result)

    @builtins.property
    def version(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Specify the versions to install.

        :default: - Install the latest version
        '''
        result = self._values.get("version")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NamedPackageOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.NatGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"eip_allocation_ids": "eipAllocationIds"},
)
class NatGatewayProps:
    def __init__(
        self,
        *,
        eip_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''Properties for a NAT gateway.

        :param eip_allocation_ids: EIP allocation IDs for the NAT gateways. Default: - No fixed EIPs allocated for the NAT gateways

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            nat_gateway_props = ec2.NatGatewayProps(
                eip_allocation_ids=["eipAllocationIds"]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__addd8acc808c4965634311e54a7ffc0e3ebe29f2170d0d62750af3ad0b8f0a25)
            check_type(argname="argument eip_allocation_ids", value=eip_allocation_ids, expected_type=type_hints["eip_allocation_ids"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if eip_allocation_ids is not None:
            self._values["eip_allocation_ids"] = eip_allocation_ids

    @builtins.property
    def eip_allocation_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''EIP allocation IDs for the NAT gateways.

        :default: - No fixed EIPs allocated for the NAT gateways
        '''
        result = self._values.get("eip_allocation_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NatGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class NatInstanceImage(
    LookupMachineImage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.NatInstanceImage",
):
    '''Machine image representing the latest NAT instance image.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        nat_instance_image = ec2.NatInstanceImage()
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.NatInstanceProps",
    jsii_struct_bases=[],
    name_mapping={
        "instance_type": "instanceType",
        "default_allowed_traffic": "defaultAllowedTraffic",
        "key_name": "keyName",
        "key_pair": "keyPair",
        "machine_image": "machineImage",
        "security_group": "securityGroup",
    },
)
class NatInstanceProps:
    def __init__(
        self,
        *,
        instance_type: InstanceType,
        default_allowed_traffic: typing.Optional["NatTrafficDirection"] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
    ) -> None:
        '''Properties for a NAT instance.

        :param instance_type: Instance type of the NAT instance.
        :param default_allowed_traffic: Direction to allow all traffic through the NAT instance by default. By default, inbound and outbound traffic is allowed. If you set this to another value than INBOUND_AND_OUTBOUND, you must configure the NAT instance's security groups in another way, either by passing in a fully configured Security Group using the ``securityGroup`` property, or by configuring it using the ``.securityGroup`` or ``.connections`` members after passing the NAT Instance Provider to a Vpc. Default: NatTrafficDirection.INBOUND_AND_OUTBOUND
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param machine_image: The machine image (AMI) to use. By default, will do an AMI lookup for the latest NAT instance image. If you have a specific AMI ID you want to use, pass a ``GenericLinuxImage``. For example:: ec2.NatProvider.instance({ instanceType: new ec2.InstanceType('t3.micro'), machineImage: new ec2.GenericLinuxImage({ 'us-east-2': 'ami-0f9c61b5a562a16af' }) }) Default: - Latest NAT instance image
        :param security_group: Security Group for NAT instances. Default: - A new security group will be created

        :exampleMetadata: lit=aws-ec2/test/integ.nat-instances.lit.ts infused

        Example::

            # Configure the `natGatewayProvider` when defining a Vpc
            nat_gateway_provider = ec2.NatProvider.instance(
                instance_type=ec2.InstanceType("t3.small")
            )
            
            vpc = ec2.Vpc(self, "MyVpc",
                nat_gateway_provider=nat_gateway_provider,
            
                # The 'natGateways' parameter now controls the number of NAT instances
                nat_gateways=2
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d7c7c717447859e1ccc181bc97f7752cc3f7fa7afaee4c3a4266eeac32c08643)
            check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
            check_type(argname="argument default_allowed_traffic", value=default_allowed_traffic, expected_type=type_hints["default_allowed_traffic"])
            check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
            check_type(argname="argument key_pair", value=key_pair, expected_type=type_hints["key_pair"])
            check_type(argname="argument machine_image", value=machine_image, expected_type=type_hints["machine_image"])
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "instance_type": instance_type,
        }
        if default_allowed_traffic is not None:
            self._values["default_allowed_traffic"] = default_allowed_traffic
        if key_name is not None:
            self._values["key_name"] = key_name
        if key_pair is not None:
            self._values["key_pair"] = key_pair
        if machine_image is not None:
            self._values["machine_image"] = machine_image
        if security_group is not None:
            self._values["security_group"] = security_group

    @builtins.property
    def instance_type(self) -> InstanceType:
        '''Instance type of the NAT instance.'''
        result = self._values.get("instance_type")
        assert result is not None, "Required property 'instance_type' is missing"
        return typing.cast(InstanceType, result)

    @builtins.property
    def default_allowed_traffic(self) -> typing.Optional["NatTrafficDirection"]:
        '''Direction to allow all traffic through the NAT instance by default.

        By default, inbound and outbound traffic is allowed.

        If you set this to another value than INBOUND_AND_OUTBOUND, you must
        configure the NAT instance's security groups in another way, either by
        passing in a fully configured Security Group using the ``securityGroup``
        property, or by configuring it using the ``.securityGroup`` or
        ``.connections`` members after passing the NAT Instance Provider to a Vpc.

        :default: NatTrafficDirection.INBOUND_AND_OUTBOUND
        '''
        result = self._values.get("default_allowed_traffic")
        return typing.cast(typing.Optional["NatTrafficDirection"], result)

    @builtins.property
    def key_name(self) -> typing.Optional[builtins.str]:
        '''(deprecated) Name of SSH keypair to grant access to instance.

        :default: - No SSH access will be possible.

        :deprecated: - Use ``keyPair`` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair

        :stability: deprecated
        '''
        result = self._values.get("key_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def key_pair(self) -> typing.Optional[IKeyPair]:
        '''The SSH keypair to grant access to the instance.

        :default: - No SSH access will be possible.
        '''
        result = self._values.get("key_pair")
        return typing.cast(typing.Optional[IKeyPair], result)

    @builtins.property
    def machine_image(self) -> typing.Optional[IMachineImage]:
        '''The machine image (AMI) to use.

        By default, will do an AMI lookup for the latest NAT instance image.

        If you have a specific AMI ID you want to use, pass a ``GenericLinuxImage``. For example::

           ec2.NatProvider.instance(
               instance_type=ec2.InstanceType("t3.micro"),
               machine_image=ec2.GenericLinuxImage({
                   "us-east-2": "ami-0f9c61b5a562a16af"
               })
           )

        :default: - Latest NAT instance image
        '''
        result = self._values.get("machine_image")
        return typing.cast(typing.Optional[IMachineImage], result)

    @builtins.property
    def security_group(self) -> typing.Optional[ISecurityGroup]:
        '''Security Group for NAT instances.

        :default: - A new security group will be created
        '''
        result = self._values.get("security_group")
        return typing.cast(typing.Optional[ISecurityGroup], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NatInstanceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class NatProvider(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.NatProvider",
):
    '''NAT providers.

    Determines what type of NAT provider to create, either NAT gateways or NAT
    instance.

    :exampleMetadata: lit=aws-ec2/test/integ.nat-instances.lit.ts infused

    Example::

        # Configure the `natGatewayProvider` when defining a Vpc
        nat_gateway_provider = ec2.NatProvider.instance(
            instance_type=ec2.InstanceType("t3.small")
        )
        
        vpc = ec2.Vpc(self, "MyVpc",
            nat_gateway_provider=nat_gateway_provider,
        
            # The 'natGateways' parameter now controls the number of NAT instances
            nat_gateways=2
        )
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="gateway")
    @builtins.classmethod
    def gateway(
        cls,
        *,
        eip_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "NatProvider":
        '''Use NAT Gateways to provide NAT services for your VPC.

        NAT gateways are managed by AWS.

        :param eip_allocation_ids: EIP allocation IDs for the NAT gateways. Default: - No fixed EIPs allocated for the NAT gateways

        :see: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html
        '''
        props = NatGatewayProps(eip_allocation_ids=eip_allocation_ids)

        return typing.cast("NatProvider", jsii.sinvoke(cls, "gateway", [props]))

    @jsii.member(jsii_name="instance")
    @builtins.classmethod
    def instance(
        cls,
        *,
        instance_type: InstanceType,
        default_allowed_traffic: typing.Optional["NatTrafficDirection"] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
    ) -> "NatInstanceProvider":
        '''Use NAT instances to provide NAT services for your VPC.

        NAT instances are managed by you, but in return allow more configuration.

        Be aware that instances created using this provider will not be
        automatically replaced if they are stopped for any reason. You should implement
        your own NatProvider based on AutoScaling groups if you need that.

        :param instance_type: Instance type of the NAT instance.
        :param default_allowed_traffic: Direction to allow all traffic through the NAT instance by default. By default, inbound and outbound traffic is allowed. If you set this to another value than INBOUND_AND_OUTBOUND, you must configure the NAT instance's security groups in another way, either by passing in a fully configured Security Group using the ``securityGroup`` property, or by configuring it using the ``.securityGroup`` or ``.connections`` members after passing the NAT Instance Provider to a Vpc. Default: NatTrafficDirection.INBOUND_AND_OUTBOUND
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param machine_image: The machine image (AMI) to use. By default, will do an AMI lookup for the latest NAT instance image. If you have a specific AMI ID you want to use, pass a ``GenericLinuxImage``. For example:: ec2.NatProvider.instance({ instanceType: new ec2.InstanceType('t3.micro'), machineImage: new ec2.GenericLinuxImage({ 'us-east-2': 'ami-0f9c61b5a562a16af' }) }) Default: - Latest NAT instance image
        :param security_group: Security Group for NAT instances. Default: - A new security group will be created

        :see: https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html
        '''
        props = NatInstanceProps(
            instance_type=instance_type,
            default_allowed_traffic=default_allowed_traffic,
            key_name=key_name,
            key_pair=key_pair,
            machine_image=machine_image,
            security_group=security_group,
        )

        return typing.cast("NatInstanceProvider", jsii.sinvoke(cls, "instance", [props]))

    @jsii.member(jsii_name="configureNat")
    @abc.abstractmethod
    def configure_nat(
        self,
        *,
        nat_subnets: typing.Sequence["PublicSubnet"],
        private_subnets: typing.Sequence["PrivateSubnet"],
        vpc: "Vpc",
    ) -> None:
        '''Called by the VPC to configure NAT.

        Don't call this directly, the VPC will call it automatically.

        :param nat_subnets: The public subnets where the NAT providers need to be placed.
        :param private_subnets: The private subnets that need to route through the NAT providers. There may be more private subnets than public subnets with NAT providers.
        :param vpc: The VPC we're configuring NAT for.
        '''
        ...

    @jsii.member(jsii_name="configureSubnet")
    @abc.abstractmethod
    def configure_subnet(self, subnet: "PrivateSubnet") -> None:
        '''Configures subnet with the gateway.

        Don't call this directly, the VPC will call it automatically.

        :param subnet: -
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="configuredGateways")
    @abc.abstractmethod
    def configured_gateways(self) -> typing.List[GatewayConfig]:
        '''Return list of gateways spawned by the provider.'''
        ...


class _NatProviderProxy(NatProvider):
    @jsii.member(jsii_name="configureNat")
    def configure_nat(
        self,
        *,
        nat_subnets: typing.Sequence["PublicSubnet"],
        private_subnets: typing.Sequence["PrivateSubnet"],
        vpc: "Vpc",
    ) -> None:
        '''Called by the VPC to configure NAT.

        Don't call this directly, the VPC will call it automatically.

        :param nat_subnets: The public subnets where the NAT providers need to be placed.
        :param private_subnets: The private subnets that need to route through the NAT providers. There may be more private subnets than public subnets with NAT providers.
        :param vpc: The VPC we're configuring NAT for.
        '''
        options = ConfigureNatOptions(
            nat_subnets=nat_subnets, private_subnets=private_subnets, vpc=vpc
        )

        return typing.cast(None, jsii.invoke(self, "configureNat", [options]))

    @jsii.member(jsii_name="configureSubnet")
    def configure_subnet(self, subnet: "PrivateSubnet") -> None:
        '''Configures subnet with the gateway.

        Don't call this directly, the VPC will call it automatically.

        :param subnet: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e0f554709187c5ab170b32fa16ce08a52f06ecc68057cedcda4b7556149eea7)
            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
        return typing.cast(None, jsii.invoke(self, "configureSubnet", [subnet]))

    @builtins.property
    @jsii.member(jsii_name="configuredGateways")
    def configured_gateways(self) -> typing.List[GatewayConfig]:
        '''Return list of gateways spawned by the provider.'''
        return typing.cast(typing.List[GatewayConfig], jsii.get(self, "configuredGateways"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, NatProvider).__jsii_proxy_class__ = lambda : _NatProviderProxy


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.NatTrafficDirection")
class NatTrafficDirection(enum.Enum):
    '''Direction of traffic to allow all by default.

    :exampleMetadata: infused

    Example::

        # instance_type: ec2.InstanceType
        
        
        provider = ec2.NatProvider.instance(
            instance_type=instance_type,
            default_allowed_traffic=ec2.NatTrafficDirection.OUTBOUND_ONLY
        )
        ec2.Vpc(self, "TheVPC",
            nat_gateway_provider=provider
        )
        provider.connections.allow_from(ec2.Peer.ipv4("1.2.3.4/8"), ec2.Port.tcp(80))
    '''

    OUTBOUND_ONLY = "OUTBOUND_ONLY"
    '''Allow all outbound traffic and disallow all inbound traffic.'''
    INBOUND_AND_OUTBOUND = "INBOUND_AND_OUTBOUND"
    '''Allow all outbound and inbound traffic.'''
    NONE = "NONE"
    '''Disallow all outbound and inbound traffic.'''


@jsii.implements(INetworkAcl)
class NetworkAcl(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.NetworkAcl",
):
    '''Define a new custom network ACL.

    By default, will deny all inbound and outbound traffic unless entries are
    added explicitly allowing it.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # subnet: ec2.Subnet
        # subnet_filter: ec2.SubnetFilter
        # vpc: ec2.Vpc
        
        network_acl = ec2.NetworkAcl(self, "MyNetworkAcl",
            vpc=vpc,
        
            # the properties below are optional
            network_acl_name="networkAclName",
            subnet_selection=ec2.SubnetSelection(
                availability_zones=["availabilityZones"],
                one_per_az=False,
                subnet_filters=[subnet_filter],
                subnet_group_name="subnetGroupName",
                subnets=[subnet],
                subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        network_acl_name: typing.Optional[builtins.str] = None,
        subnet_selection: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC in which to create the NetworkACL.
        :param network_acl_name: The name of the NetworkAcl. Since the NetworkAcl resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag. Default: CDK generated name
        :param subnet_selection: Subnets in the given VPC to associate the ACL with. More subnets can always be added later by calling ``associateWithSubnets()``. Default: - No subnets associated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdf72e51c58e65bab33357b7df12d3ce802f1165c4dc64415bfac7ead4059eb0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = NetworkAclProps(
            vpc=vpc,
            network_acl_name=network_acl_name,
            subnet_selection=subnet_selection,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromNetworkAclId")
    @builtins.classmethod
    def from_network_acl_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        network_acl_id: builtins.str,
    ) -> INetworkAcl:
        '''Import an existing NetworkAcl into this app.

        :param scope: -
        :param id: -
        :param network_acl_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00fedeea0964c8a6bd2508f4ea6c217eb7a85085826373032f5190381821e799)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument network_acl_id", value=network_acl_id, expected_type=type_hints["network_acl_id"])
        return typing.cast(INetworkAcl, jsii.sinvoke(cls, "fromNetworkAclId", [scope, id, network_acl_id]))

    @jsii.member(jsii_name="addEntry")
    def add_entry(
        self,
        id: builtins.str,
        *,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
    ) -> "NetworkAclEntry":
        '''Add a new entry to the ACL.

        :param id: -
        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__16785fa2c2b7254eaadd33cae07af702c325134c6581e041b66db73afae0629c)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = CommonNetworkAclEntryOptions(
            cidr=cidr,
            rule_number=rule_number,
            traffic=traffic,
            direction=direction,
            network_acl_entry_name=network_acl_entry_name,
            rule_action=rule_action,
        )

        return typing.cast("NetworkAclEntry", jsii.invoke(self, "addEntry", [id, options]))

    @jsii.member(jsii_name="associateWithSubnet")
    def associate_with_subnet(
        self,
        id: builtins.str,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence["SubnetFilter"]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional["SubnetType"] = None,
    ) -> None:
        '''Associate the ACL with a given set of subnets.

        :param id: -
        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__757295a20459bdecbba45d5952a6bfab627e0a3218daec9e567df784604310cb)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        selection = SubnetSelection(
            availability_zones=availability_zones,
            one_per_az=one_per_az,
            subnet_filters=subnet_filters,
            subnet_group_name=subnet_group_name,
            subnets=subnets,
            subnet_type=subnet_type,
        )

        return typing.cast(None, jsii.invoke(self, "associateWithSubnet", [id, selection]))

    @builtins.property
    @jsii.member(jsii_name="networkAclId")
    def network_acl_id(self) -> builtins.str:
        '''The ID of the NetworkACL.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "networkAclId"))

    @builtins.property
    @jsii.member(jsii_name="networkAclVpcId")
    def network_acl_vpc_id(self) -> builtins.str:
        '''The VPC ID for this NetworkACL.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "networkAclVpcId"))


@jsii.implements(INetworkAclEntry)
class NetworkAclEntry(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.NetworkAclEntry",
):
    '''Define an entry in a Network ACL table.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # acl_cidr: ec2.AclCidr
        # acl_traffic: ec2.AclTraffic
        # network_acl: ec2.NetworkAcl
        
        network_acl_entry = ec2.NetworkAclEntry(self, "MyNetworkAclEntry",
            cidr=acl_cidr,
            network_acl=network_acl,
            rule_number=123,
            traffic=acl_traffic,
        
            # the properties below are optional
            direction=ec2.TrafficDirection.EGRESS,
            network_acl_entry_name="networkAclEntryName",
            rule_action=ec2.Action.ALLOW
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_acl: INetworkAcl,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param network_acl: The network ACL this entry applies to.
        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__36eccb106dd699342caabff87b4a9c8ae3591d6fd2af3021ab67f3dd055a58fb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = NetworkAclEntryProps(
            network_acl=network_acl,
            cidr=cidr,
            rule_number=rule_number,
            traffic=traffic,
            direction=direction,
            network_acl_entry_name=network_acl_entry_name,
            rule_action=rule_action,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="networkAcl")
    def network_acl(self) -> INetworkAcl:
        '''The network ACL.'''
        return typing.cast(INetworkAcl, jsii.get(self, "networkAcl"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.NetworkAclEntryProps",
    jsii_struct_bases=[CommonNetworkAclEntryOptions],
    name_mapping={
        "cidr": "cidr",
        "rule_number": "ruleNumber",
        "traffic": "traffic",
        "direction": "direction",
        "network_acl_entry_name": "networkAclEntryName",
        "rule_action": "ruleAction",
        "network_acl": "networkAcl",
    },
)
class NetworkAclEntryProps(CommonNetworkAclEntryOptions):
    def __init__(
        self,
        *,
        cidr: AclCidr,
        rule_number: jsii.Number,
        traffic: AclTraffic,
        direction: typing.Optional["TrafficDirection"] = None,
        network_acl_entry_name: typing.Optional[builtins.str] = None,
        rule_action: typing.Optional[Action] = None,
        network_acl: INetworkAcl,
    ) -> None:
        '''Properties to create NetworkAclEntry.

        :param cidr: The CIDR range to allow or deny.
        :param rule_number: Rule number to assign to the entry, such as 100. ACL entries are processed in ascending order by rule number. Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        :param traffic: What kind of traffic this ACL rule applies to.
        :param direction: Traffic direction, with respect to the subnet, this rule applies to. Default: TrafficDirection.INGRESS
        :param network_acl_entry_name: The name of the NetworkAclEntry. It is not recommended to use an explicit group name. Default: If you don't specify a NetworkAclName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        :param rule_action: Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny". Any traffic that is not explicitly allowed is automatically denied in a custom ACL, all traffic is automatically allowed in a default ACL. Default: ALLOW
        :param network_acl: The network ACL this entry applies to.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # acl_cidr: ec2.AclCidr
            # acl_traffic: ec2.AclTraffic
            # network_acl: ec2.NetworkAcl
            
            network_acl_entry_props = ec2.NetworkAclEntryProps(
                cidr=acl_cidr,
                network_acl=network_acl,
                rule_number=123,
                traffic=acl_traffic,
            
                # the properties below are optional
                direction=ec2.TrafficDirection.EGRESS,
                network_acl_entry_name="networkAclEntryName",
                rule_action=ec2.Action.ALLOW
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25285d8c5e40053fd948514da7a4ec2655e352c65cdcfbd382401943a4e35f21)
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument rule_number", value=rule_number, expected_type=type_hints["rule_number"])
            check_type(argname="argument traffic", value=traffic, expected_type=type_hints["traffic"])
            check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
            check_type(argname="argument network_acl_entry_name", value=network_acl_entry_name, expected_type=type_hints["network_acl_entry_name"])
            check_type(argname="argument rule_action", value=rule_action, expected_type=type_hints["rule_action"])
            check_type(argname="argument network_acl", value=network_acl, expected_type=type_hints["network_acl"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "cidr": cidr,
            "rule_number": rule_number,
            "traffic": traffic,
            "network_acl": network_acl,
        }
        if direction is not None:
            self._values["direction"] = direction
        if network_acl_entry_name is not None:
            self._values["network_acl_entry_name"] = network_acl_entry_name
        if rule_action is not None:
            self._values["rule_action"] = rule_action

    @builtins.property
    def cidr(self) -> AclCidr:
        '''The CIDR range to allow or deny.'''
        result = self._values.get("cidr")
        assert result is not None, "Required property 'cidr' is missing"
        return typing.cast(AclCidr, result)

    @builtins.property
    def rule_number(self) -> jsii.Number:
        '''Rule number to assign to the entry, such as 100.

        ACL entries are processed in ascending order by rule number.
        Entries can't use the same rule number unless one is an egress rule and the other is an ingress rule.
        '''
        result = self._values.get("rule_number")
        assert result is not None, "Required property 'rule_number' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def traffic(self) -> AclTraffic:
        '''What kind of traffic this ACL rule applies to.'''
        result = self._values.get("traffic")
        assert result is not None, "Required property 'traffic' is missing"
        return typing.cast(AclTraffic, result)

    @builtins.property
    def direction(self) -> typing.Optional["TrafficDirection"]:
        '''Traffic direction, with respect to the subnet, this rule applies to.

        :default: TrafficDirection.INGRESS
        '''
        result = self._values.get("direction")
        return typing.cast(typing.Optional["TrafficDirection"], result)

    @builtins.property
    def network_acl_entry_name(self) -> typing.Optional[builtins.str]:
        '''The name of the NetworkAclEntry.

        It is not recommended to use an explicit group name.

        :default:

        If you don't specify a NetworkAclName, AWS CloudFormation generates a
        unique physical ID and uses that ID for the group name.
        '''
        result = self._values.get("network_acl_entry_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def rule_action(self) -> typing.Optional[Action]:
        '''Whether to allow or deny traffic that matches the rule; valid values are "allow" or "deny".

        Any traffic that is not explicitly allowed is automatically denied in a custom
        ACL, all traffic is automatically allowed in a default ACL.

        :default: ALLOW
        '''
        result = self._values.get("rule_action")
        return typing.cast(typing.Optional[Action], result)

    @builtins.property
    def network_acl(self) -> INetworkAcl:
        '''The network ACL this entry applies to.'''
        result = self._values.get("network_acl")
        assert result is not None, "Required property 'network_acl' is missing"
        return typing.cast(INetworkAcl, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NetworkAclEntryProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.NetworkAclProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc": "vpc",
        "network_acl_name": "networkAclName",
        "subnet_selection": "subnetSelection",
    },
)
class NetworkAclProps:
    def __init__(
        self,
        *,
        vpc: IVpc,
        network_acl_name: typing.Optional[builtins.str] = None,
        subnet_selection: typing.Optional[typing.Union["SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''Properties to create NetworkAcl.

        :param vpc: The VPC in which to create the NetworkACL.
        :param network_acl_name: The name of the NetworkAcl. Since the NetworkAcl resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag. Default: CDK generated name
        :param subnet_selection: Subnets in the given VPC to associate the ACL with. More subnets can always be added later by calling ``associateWithSubnets()``. Default: - No subnets associated

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # subnet: ec2.Subnet
            # subnet_filter: ec2.SubnetFilter
            # vpc: ec2.Vpc
            
            network_acl_props = ec2.NetworkAclProps(
                vpc=vpc,
            
                # the properties below are optional
                network_acl_name="networkAclName",
                subnet_selection=ec2.SubnetSelection(
                    availability_zones=["availabilityZones"],
                    one_per_az=False,
                    subnet_filters=[subnet_filter],
                    subnet_group_name="subnetGroupName",
                    subnets=[subnet],
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
                )
            )
        '''
        if isinstance(subnet_selection, dict):
            subnet_selection = SubnetSelection(**subnet_selection)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__918b07b3c8f8cedc0cf766224969cc032fd164624c47a16176237186526566b1)
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument network_acl_name", value=network_acl_name, expected_type=type_hints["network_acl_name"])
            check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc": vpc,
        }
        if network_acl_name is not None:
            self._values["network_acl_name"] = network_acl_name
        if subnet_selection is not None:
            self._values["subnet_selection"] = subnet_selection

    @builtins.property
    def vpc(self) -> IVpc:
        '''The VPC in which to create the NetworkACL.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast(IVpc, result)

    @builtins.property
    def network_acl_name(self) -> typing.Optional[builtins.str]:
        '''The name of the NetworkAcl.

        Since the NetworkAcl resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag.

        :default: CDK generated name
        '''
        result = self._values.get("network_acl_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def subnet_selection(self) -> typing.Optional["SubnetSelection"]:
        '''Subnets in the given VPC to associate the ACL with.

        More subnets can always be added later by calling
        ``associateWithSubnets()``.

        :default: - No subnets associated
        '''
        result = self._values.get("subnet_selection")
        return typing.cast(typing.Optional["SubnetSelection"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NetworkAclProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.OperatingSystemType")
class OperatingSystemType(enum.Enum):
    '''The OS type of a particular image.

    :exampleMetadata: lit=aws-ec2/test/example.images.lit.ts infused

    Example::

        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.MachineImage.latest_amazon_linux(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE,
            cpu_type=ec2.AmazonLinuxCpuType.X86_64
        )
        
        # Pick a Windows edition to use
        windows = ec2.MachineImage.latest_windows(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Read AMI id from SSM parameter store
        ssm = ec2.MachineImage.from_ssm_parameter("/my/ami", os=ec2.OperatingSystemType.LINUX)
        
        # Look up the most recent image matching a set of AMI filters.
        # In this case, look up the NAT instance AMI, by using a wildcard
        # in the 'name' field:
        nat_ami = ec2.MachineImage.lookup(
            name="amzn-ami-vpc-nat-*",
            owners=["amazon"]
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        linux = ec2.MachineImage.generic_linux({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
        
        # For other custom (Windows) images, instantiate a `GenericWindowsImage` with
        # a map giving the AMI to in for each region:
        generic_windows = ec2.MachineImage.generic_windows({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    LINUX = "LINUX"
    WINDOWS = "WINDOWS"
    UNKNOWN = "UNKNOWN"
    '''Used when the type of the operating system is not known (for example, for imported Auto-Scaling Groups).'''


class Peer(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.Peer"):
    '''Peer object factories (to be used in Security Group management).

    The static methods on this object can be used to create peer objects
    which represent a connection partner in Security Group rules.

    Use this object if you need to represent connection partners using plain IP
    addresses, or a prefix list ID.

    If you want to address a connection partner by Security Group, you can just
    use the Security Group (or the construct that contains a Security Group)
    directly, as it already implements ``IPeer``.

    :exampleMetadata: infused

    Example::

        # instance_type: ec2.InstanceType
        
        
        provider = ec2.NatProvider.instance(
            instance_type=instance_type,
            default_allowed_traffic=ec2.NatTrafficDirection.OUTBOUND_ONLY
        )
        ec2.Vpc(self, "TheVPC",
            nat_gateway_provider=provider
        )
        provider.connections.allow_from(ec2.Peer.ipv4("1.2.3.4/8"), ec2.Port.tcp(80))
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="anyIpv4")
    @builtins.classmethod
    def any_ipv4(cls) -> IPeer:
        '''Any IPv4 address.'''
        return typing.cast(IPeer, jsii.sinvoke(cls, "anyIpv4", []))

    @jsii.member(jsii_name="anyIpv6")
    @builtins.classmethod
    def any_ipv6(cls) -> IPeer:
        '''Any IPv6 address.'''
        return typing.cast(IPeer, jsii.sinvoke(cls, "anyIpv6", []))

    @jsii.member(jsii_name="ipv4")
    @builtins.classmethod
    def ipv4(cls, cidr_ip: builtins.str) -> IPeer:
        '''Create an IPv4 peer from a CIDR.

        :param cidr_ip: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__210a053f19d643e5f27f8152f0350703ea14905e76edde6bbfe73c476b9806fc)
            check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
        return typing.cast(IPeer, jsii.sinvoke(cls, "ipv4", [cidr_ip]))

    @jsii.member(jsii_name="ipv6")
    @builtins.classmethod
    def ipv6(cls, cidr_ip: builtins.str) -> IPeer:
        '''Create an IPv6 peer from a CIDR.

        :param cidr_ip: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe52d92bdafabcc16b1d7177b08a56f9e8058882c6924f341f0afe19dc53d040)
            check_type(argname="argument cidr_ip", value=cidr_ip, expected_type=type_hints["cidr_ip"])
        return typing.cast(IPeer, jsii.sinvoke(cls, "ipv6", [cidr_ip]))

    @jsii.member(jsii_name="prefixList")
    @builtins.classmethod
    def prefix_list(cls, prefix_list_id: builtins.str) -> IPeer:
        '''A prefix list.

        :param prefix_list_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ba7a76a669f261e0d00aaa251049148bd3ec9e49ef5d2263d637ddc7a07cf97e)
            check_type(argname="argument prefix_list_id", value=prefix_list_id, expected_type=type_hints["prefix_list_id"])
        return typing.cast(IPeer, jsii.sinvoke(cls, "prefixList", [prefix_list_id]))

    @jsii.member(jsii_name="securityGroupId")
    @builtins.classmethod
    def security_group_id(
        cls,
        security_group_id: builtins.str,
        source_security_group_owner_id: typing.Optional[builtins.str] = None,
    ) -> IPeer:
        '''A security group ID.

        :param security_group_id: -
        :param source_security_group_owner_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c50e745d8c4b7cc541db411d4fbaf133ad97d93fd8e648131c3e0c6bbad459a9)
            check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
            check_type(argname="argument source_security_group_owner_id", value=source_security_group_owner_id, expected_type=type_hints["source_security_group_owner_id"])
        return typing.cast(IPeer, jsii.sinvoke(cls, "securityGroupId", [security_group_id, source_security_group_owner_id]))


@jsii.implements(IPlacementGroup)
class PlacementGroup(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.PlacementGroup",
):
    '''Defines a placement group.

    Placement groups give you fine-grained control over
    where your instances are provisioned.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        placement_group = ec2.PlacementGroup(self, "MyPlacementGroup",
            partitions=123,
            placement_group_name="placementGroupName",
            spread_level=ec2.PlacementGroupSpreadLevel.HOST,
            strategy=ec2.PlacementGroupStrategy.CLUSTER
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        partitions: typing.Optional[jsii.Number] = None,
        placement_group_name: typing.Optional[builtins.str] = None,
        spread_level: typing.Optional["PlacementGroupSpreadLevel"] = None,
        strategy: typing.Optional["PlacementGroupStrategy"] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param partitions: The number of partitions. Valid only when Strategy is set to partition. Default: 0
        :param placement_group_name: the name of this placement group. Default: - generated by CFN
        :param spread_level: Places instances on distinct hardware. Spread placement groups are recommended for applications that have a small number of critical instances that should be kept separate from each other. Launching instances in a spread level placement group reduces the risk of simultaneous failures that might occur when instances share the same equipment. Spread level placement groups provide access to distinct hardware, and are therefore suitable for mixing instance types or launching instances over time. If you start or launch an instance in a spread placement group and there is insufficient unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware available over time, so you can try your request again later. Placement groups can spread instances across racks or hosts. You can use host level spread placement groups only with AWS Outposts. Default: - no spread level
        :param strategy: Which strategy to use when launching instances. Default: - ``PlacementGroupStrategy.PARTITION`` if ``partitions`` is defined, ``CLUSTER`` otherwise
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__427650d4bb55511bd9980d9c08a92379b4dacfbed10cb8f3fb827060e435ce4c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = PlacementGroupProps(
            partitions=partitions,
            placement_group_name=placement_group_name,
            spread_level=spread_level,
            strategy=strategy,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromPlacementGroupName")
    @builtins.classmethod
    def from_placement_group_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        placement_group_name: builtins.str,
    ) -> IPlacementGroup:
        '''Import a PlacementGroup by its arn.

        :param scope: -
        :param id: -
        :param placement_group_name: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__13fa82f0bf97dfead8eec23b1f277a7e4319f0ed1adf710d4e722997c70ea0a5)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument placement_group_name", value=placement_group_name, expected_type=type_hints["placement_group_name"])
        return typing.cast(IPlacementGroup, jsii.sinvoke(cls, "fromPlacementGroupName", [scope, id, placement_group_name]))

    @builtins.property
    @jsii.member(jsii_name="placementGroupName")
    def placement_group_name(self) -> builtins.str:
        '''The name of this placement group.'''
        return typing.cast(builtins.str, jsii.get(self, "placementGroupName"))

    @builtins.property
    @jsii.member(jsii_name="partitions")
    def partitions(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.

        Valid only when Strategy is set to PARTITION.
        '''
        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "partitions"))

    @builtins.property
    @jsii.member(jsii_name="spreadLevel")
    def spread_level(self) -> typing.Optional["PlacementGroupSpreadLevel"]:
        '''Places instances on distinct hardware.

        Spread placement groups are recommended for applications
        that have a small number of critical instances that should be kept separate from each other.
        Launching instances in a spread level placement group reduces the risk of simultaneous failures
        that might occur when instances share the same equipment.
        Spread level placement groups provide access to distinct hardware,
        and are therefore suitable for mixing instance types or launching instances over time.
        If you start or launch an instance in a spread placement group and there is insufficient
        unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware
        available over time, so you can try your request again later.
        Placement groups can spread instances across racks or hosts.
        You can use host level spread placement groups only with AWS Outposts.
        '''
        return typing.cast(typing.Optional["PlacementGroupSpreadLevel"], jsii.get(self, "spreadLevel"))

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def strategy(self) -> typing.Optional["PlacementGroupStrategy"]:
        '''Which strategy to use when launching instances.'''
        return typing.cast(typing.Optional["PlacementGroupStrategy"], jsii.get(self, "strategy"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PlacementGroupProps",
    jsii_struct_bases=[],
    name_mapping={
        "partitions": "partitions",
        "placement_group_name": "placementGroupName",
        "spread_level": "spreadLevel",
        "strategy": "strategy",
    },
)
class PlacementGroupProps:
    def __init__(
        self,
        *,
        partitions: typing.Optional[jsii.Number] = None,
        placement_group_name: typing.Optional[builtins.str] = None,
        spread_level: typing.Optional["PlacementGroupSpreadLevel"] = None,
        strategy: typing.Optional["PlacementGroupStrategy"] = None,
    ) -> None:
        '''Props for a PlacementGroup.

        :param partitions: The number of partitions. Valid only when Strategy is set to partition. Default: 0
        :param placement_group_name: the name of this placement group. Default: - generated by CFN
        :param spread_level: Places instances on distinct hardware. Spread placement groups are recommended for applications that have a small number of critical instances that should be kept separate from each other. Launching instances in a spread level placement group reduces the risk of simultaneous failures that might occur when instances share the same equipment. Spread level placement groups provide access to distinct hardware, and are therefore suitable for mixing instance types or launching instances over time. If you start or launch an instance in a spread placement group and there is insufficient unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware available over time, so you can try your request again later. Placement groups can spread instances across racks or hosts. You can use host level spread placement groups only with AWS Outposts. Default: - no spread level
        :param strategy: Which strategy to use when launching instances. Default: - ``PlacementGroupStrategy.PARTITION`` if ``partitions`` is defined, ``CLUSTER`` otherwise

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            placement_group_props = ec2.PlacementGroupProps(
                partitions=123,
                placement_group_name="placementGroupName",
                spread_level=ec2.PlacementGroupSpreadLevel.HOST,
                strategy=ec2.PlacementGroupStrategy.CLUSTER
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bef176ff3d4f0b995f951b64f05655e76cc9c2bb772b196cbcc2f473ff46aadf)
            check_type(argname="argument partitions", value=partitions, expected_type=type_hints["partitions"])
            check_type(argname="argument placement_group_name", value=placement_group_name, expected_type=type_hints["placement_group_name"])
            check_type(argname="argument spread_level", value=spread_level, expected_type=type_hints["spread_level"])
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if partitions is not None:
            self._values["partitions"] = partitions
        if placement_group_name is not None:
            self._values["placement_group_name"] = placement_group_name
        if spread_level is not None:
            self._values["spread_level"] = spread_level
        if strategy is not None:
            self._values["strategy"] = strategy

    @builtins.property
    def partitions(self) -> typing.Optional[jsii.Number]:
        '''The number of partitions.

        Valid only when Strategy is set to partition.

        :default: 0
        '''
        result = self._values.get("partitions")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def placement_group_name(self) -> typing.Optional[builtins.str]:
        '''the name of this placement group.

        :default: - generated by CFN

        :attribute: true
        '''
        result = self._values.get("placement_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def spread_level(self) -> typing.Optional["PlacementGroupSpreadLevel"]:
        '''Places instances on distinct hardware.

        Spread placement groups are recommended for applications
        that have a small number of critical instances that should be kept separate from each other.
        Launching instances in a spread level placement group reduces the risk of simultaneous failures
        that might occur when instances share the same equipment.
        Spread level placement groups provide access to distinct hardware,
        and are therefore suitable for mixing instance types or launching instances over time.
        If you start or launch an instance in a spread placement group and there is insufficient
        unique hardware to fulfill the request, the request fails. Amazon EC2 makes more distinct hardware
        available over time, so you can try your request again later.
        Placement groups can spread instances across racks or hosts.
        You can use host level spread placement groups only with AWS Outposts.

        :default: - no spread level
        '''
        result = self._values.get("spread_level")
        return typing.cast(typing.Optional["PlacementGroupSpreadLevel"], result)

    @builtins.property
    def strategy(self) -> typing.Optional["PlacementGroupStrategy"]:
        '''Which strategy to use when launching instances.

        :default: - ``PlacementGroupStrategy.PARTITION`` if ``partitions`` is defined, ``CLUSTER`` otherwise
        '''
        result = self._values.get("strategy")
        return typing.cast(typing.Optional["PlacementGroupStrategy"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PlacementGroupProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.PlacementGroupSpreadLevel")
class PlacementGroupSpreadLevel(enum.Enum):
    '''Determines how this placement group spreads instances.'''

    HOST = "HOST"
    '''Host spread level placement groups are only available with AWS Outposts.

    For host spread level placement groups, there are no restrictions for running instances per Outposts.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups-outpost.html
    '''
    RACK = "RACK"
    '''Each instance is launched on a separate rack.

    Each has its own network and power source.
    A rack spread placement group can span multiple Availability Zones in the same Region.
    For rack spread level placement groups, you can have a maximum of seven running instances per Availability Zone per group.
    '''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.PlacementGroupStrategy")
class PlacementGroupStrategy(enum.Enum):
    '''Which strategy to use when launching instances.'''

    CLUSTER = "CLUSTER"
    '''Packs instances close together inside an Availability Zone.

    This strategy enables workloads to achieve the low-latency network
    performance necessary for tightly-coupled node-to-node communication that
    is typical of high-performance computing (HPC) applications.
    '''
    PARTITION = "PARTITION"
    '''Spreads your instances across logical partitions such that groups of instances in one partition do not share the underlying hardware with groups of instances in different partitions.

    This strategy is typically used by large distributed and replicated workloads,
    such as Hadoop, Cassandra, and Kafka.
    '''
    SPREAD = "SPREAD"
    '''Strictly places a small group of instances across distinct underlying hardware to reduce correlated failures.'''


class Port(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.Port"):
    '''Interface for classes that provide the connection-specification parts of a security group rule.

    :exampleMetadata: infused

    Example::

        # instance_type: ec2.InstanceType
        
        
        provider = ec2.NatProvider.instance(
            instance_type=instance_type,
            default_allowed_traffic=ec2.NatTrafficDirection.OUTBOUND_ONLY
        )
        ec2.Vpc(self, "TheVPC",
            nat_gateway_provider=provider
        )
        provider.connections.allow_from(ec2.Peer.ipv4("1.2.3.4/8"), ec2.Port.tcp(80))
    '''

    def __init__(
        self,
        *,
        protocol: "Protocol",
        string_representation: builtins.str,
        from_port: typing.Optional[jsii.Number] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param protocol: The protocol for the range.
        :param string_representation: String representation for this object.
        :param from_port: The starting port for the range. Default: - Not included in the rule
        :param to_port: The ending port for the range. Default: - Not included in the rule
        '''
        props = PortProps(
            protocol=protocol,
            string_representation=string_representation,
            from_port=from_port,
            to_port=to_port,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="ah")
    @builtins.classmethod
    def ah(cls) -> "Port":
        '''A single AH port.'''
        return typing.cast("Port", jsii.sinvoke(cls, "ah", []))

    @jsii.member(jsii_name="allIcmp")
    @builtins.classmethod
    def all_icmp(cls) -> "Port":
        '''All ICMP traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "allIcmp", []))

    @jsii.member(jsii_name="allIcmpV6")
    @builtins.classmethod
    def all_icmp_v6(cls) -> "Port":
        '''All ICMPv6 traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "allIcmpV6", []))

    @jsii.member(jsii_name="allTcp")
    @builtins.classmethod
    def all_tcp(cls) -> "Port":
        '''Any TCP traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "allTcp", []))

    @jsii.member(jsii_name="allTraffic")
    @builtins.classmethod
    def all_traffic(cls) -> "Port":
        '''All traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "allTraffic", []))

    @jsii.member(jsii_name="allUdp")
    @builtins.classmethod
    def all_udp(cls) -> "Port":
        '''Any UDP traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "allUdp", []))

    @jsii.member(jsii_name="esp")
    @builtins.classmethod
    def esp(cls) -> "Port":
        '''A single ESP port.'''
        return typing.cast("Port", jsii.sinvoke(cls, "esp", []))

    @jsii.member(jsii_name="icmpPing")
    @builtins.classmethod
    def icmp_ping(cls) -> "Port":
        '''ICMP ping (echo) traffic.'''
        return typing.cast("Port", jsii.sinvoke(cls, "icmpPing", []))

    @jsii.member(jsii_name="icmpType")
    @builtins.classmethod
    def icmp_type(cls, type: jsii.Number) -> "Port":
        '''All codes for a single ICMP type.

        :param type: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__95b8dff2f4acc488f9cf50690ead7aaf9670da71be27099aa10e23d23920cad3)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast("Port", jsii.sinvoke(cls, "icmpType", [type]))

    @jsii.member(jsii_name="icmpTypeAndCode")
    @builtins.classmethod
    def icmp_type_and_code(cls, type: jsii.Number, code: jsii.Number) -> "Port":
        '''A specific combination of ICMP type and code.

        :param type: -
        :param code: -

        :see: https://www.iana.org/assignments/icmp-parameters/icmp-parameters.xhtml
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8bb7512bf9d9583c10357d7ba3b7e954eb11d618b5e5fdb0d4d6efde8527250b)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument code", value=code, expected_type=type_hints["code"])
        return typing.cast("Port", jsii.sinvoke(cls, "icmpTypeAndCode", [type, code]))

    @jsii.member(jsii_name="tcp")
    @builtins.classmethod
    def tcp(cls, port: jsii.Number) -> "Port":
        '''A single TCP port.

        :param port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ed27477a26261dedd74ff51476afe2182a291e66de5954640b7e4d3a5721ef5)
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        return typing.cast("Port", jsii.sinvoke(cls, "tcp", [port]))

    @jsii.member(jsii_name="tcpRange")
    @builtins.classmethod
    def tcp_range(cls, start_port: jsii.Number, end_port: jsii.Number) -> "Port":
        '''A TCP port range.

        :param start_port: -
        :param end_port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50936912c584cfa2a36269676fc55b98084d9ffb187095c90134c875fc629016)
            check_type(argname="argument start_port", value=start_port, expected_type=type_hints["start_port"])
            check_type(argname="argument end_port", value=end_port, expected_type=type_hints["end_port"])
        return typing.cast("Port", jsii.sinvoke(cls, "tcpRange", [start_port, end_port]))

    @jsii.member(jsii_name="udp")
    @builtins.classmethod
    def udp(cls, port: jsii.Number) -> "Port":
        '''A single UDP port.

        :param port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6365151a22448259d687ae93919fac9d4a047edc2e1de37a48ed7cbf767aee4e)
            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
        return typing.cast("Port", jsii.sinvoke(cls, "udp", [port]))

    @jsii.member(jsii_name="udpRange")
    @builtins.classmethod
    def udp_range(cls, start_port: jsii.Number, end_port: jsii.Number) -> "Port":
        '''A UDP port range.

        :param start_port: -
        :param end_port: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cea2c8ec112e0e1ddbd93b3d5076d84863d736e67dbee23440f816fa4b3e4ed4)
            check_type(argname="argument start_port", value=start_port, expected_type=type_hints["start_port"])
            check_type(argname="argument end_port", value=end_port, expected_type=type_hints["end_port"])
        return typing.cast("Port", jsii.sinvoke(cls, "udpRange", [start_port, end_port]))

    @jsii.member(jsii_name="toRuleJson")
    def to_rule_json(self) -> typing.Any:
        '''Produce the ingress/egress rule JSON for the given connection.'''
        return typing.cast(typing.Any, jsii.invoke(self, "toRuleJson", []))

    @jsii.member(jsii_name="toString")
    def to_string(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.invoke(self, "toString", []))

    @builtins.property
    @jsii.member(jsii_name="canInlineRule")
    def can_inline_rule(self) -> builtins.bool:
        '''Whether the rule containing this port range can be inlined into a securitygroup or not.'''
        return typing.cast(builtins.bool, jsii.get(self, "canInlineRule"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PortProps",
    jsii_struct_bases=[],
    name_mapping={
        "protocol": "protocol",
        "string_representation": "stringRepresentation",
        "from_port": "fromPort",
        "to_port": "toPort",
    },
)
class PortProps:
    def __init__(
        self,
        *,
        protocol: "Protocol",
        string_representation: builtins.str,
        from_port: typing.Optional[jsii.Number] = None,
        to_port: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Properties to create a port range.

        :param protocol: The protocol for the range.
        :param string_representation: String representation for this object.
        :param from_port: The starting port for the range. Default: - Not included in the rule
        :param to_port: The ending port for the range. Default: - Not included in the rule

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            port_props = ec2.PortProps(
                protocol=ec2.Protocol.ALL,
                string_representation="stringRepresentation",
            
                # the properties below are optional
                from_port=123,
                to_port=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f53682a2161eb5a4099c7690d0c7c734a1709dcaa9d6100123241e4bc281121)
            check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
            check_type(argname="argument string_representation", value=string_representation, expected_type=type_hints["string_representation"])
            check_type(argname="argument from_port", value=from_port, expected_type=type_hints["from_port"])
            check_type(argname="argument to_port", value=to_port, expected_type=type_hints["to_port"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "protocol": protocol,
            "string_representation": string_representation,
        }
        if from_port is not None:
            self._values["from_port"] = from_port
        if to_port is not None:
            self._values["to_port"] = to_port

    @builtins.property
    def protocol(self) -> "Protocol":
        '''The protocol for the range.'''
        result = self._values.get("protocol")
        assert result is not None, "Required property 'protocol' is missing"
        return typing.cast("Protocol", result)

    @builtins.property
    def string_representation(self) -> builtins.str:
        '''String representation for this object.'''
        result = self._values.get("string_representation")
        assert result is not None, "Required property 'string_representation' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def from_port(self) -> typing.Optional[jsii.Number]:
        '''The starting port for the range.

        :default: - Not included in the rule
        '''
        result = self._values.get("from_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def to_port(self) -> typing.Optional[jsii.Number]:
        '''The ending port for the range.

        :default: - Not included in the rule
        '''
        result = self._values.get("to_port")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PortProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IPrefixList)
class PrefixList(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.PrefixList",
):
    '''A managed prefix list.

    :resource: AWS::EC2::PrefixList
    :exampleMetadata: infused

    Example::

        ec2.PrefixList(self, "EmptyPrefixList",
            max_entries=100
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        address_family: typing.Optional[AddressFamily] = None,
        entries: typing.Optional[typing.Sequence[typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        prefix_list_name: typing.Optional[builtins.str] = None,
        max_entries: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param address_family: The address family of the prefix list. Default: AddressFamily.IP_V4
        :param entries: The list of entries for the prefix list. Default: []
        :param prefix_list_name: The name of the prefix list. Default: None
        :param max_entries: The maximum number of entries for the prefix list. Default: Automatically-calculated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a8acc7e3b44d925ae96c4cd41872cf18233bdd11aba643610749ed9a484c5456)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = PrefixListProps(
            address_family=address_family,
            entries=entries,
            prefix_list_name=prefix_list_name,
            max_entries=max_entries,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromPrefixListId")
    @builtins.classmethod
    def from_prefix_list_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        prefix_list_id: builtins.str,
    ) -> IPrefixList:
        '''Look up prefix list by id.

        :param scope: -
        :param id: -
        :param prefix_list_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__11d084123507c2ab32a82e79ad64d9ff7d0962d3562cc06f04b8e900b3c6622b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument prefix_list_id", value=prefix_list_id, expected_type=type_hints["prefix_list_id"])
        return typing.cast(IPrefixList, jsii.sinvoke(cls, "fromPrefixListId", [scope, id, prefix_list_id]))

    @builtins.property
    @jsii.member(jsii_name="addressFamily")
    def address_family(self) -> builtins.str:
        '''The address family of the prefix list.'''
        return typing.cast(builtins.str, jsii.get(self, "addressFamily"))

    @builtins.property
    @jsii.member(jsii_name="ownerId")
    def owner_id(self) -> builtins.str:
        '''The owner ID of the prefix list.'''
        return typing.cast(builtins.str, jsii.get(self, "ownerId"))

    @builtins.property
    @jsii.member(jsii_name="prefixListArn")
    def prefix_list_arn(self) -> builtins.str:
        '''The ARN of the prefix list.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "prefixListArn"))

    @builtins.property
    @jsii.member(jsii_name="prefixListId")
    def prefix_list_id(self) -> builtins.str:
        '''The ID of the prefix list.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "prefixListId"))

    @builtins.property
    @jsii.member(jsii_name="prefixListName")
    def prefix_list_name(self) -> builtins.str:
        '''The name of the prefix list.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "prefixListName"))

    @builtins.property
    @jsii.member(jsii_name="version")
    def version(self) -> jsii.Number:
        '''The version of the prefix list.'''
        return typing.cast(jsii.Number, jsii.get(self, "version"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PrefixListOptions",
    jsii_struct_bases=[],
    name_mapping={"max_entries": "maxEntries"},
)
class PrefixListOptions:
    def __init__(self, *, max_entries: typing.Optional[jsii.Number] = None) -> None:
        '''Options to add a prefix list.

        :param max_entries: The maximum number of entries for the prefix list. Default: Automatically-calculated

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            prefix_list_options = ec2.PrefixListOptions(
                max_entries=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7cc34528909d71054422fc4b6e3439757c430d31f6f33a0af82b4c5b61e57e19)
            check_type(argname="argument max_entries", value=max_entries, expected_type=type_hints["max_entries"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if max_entries is not None:
            self._values["max_entries"] = max_entries

    @builtins.property
    def max_entries(self) -> typing.Optional[jsii.Number]:
        '''The maximum number of entries for the prefix list.

        :default: Automatically-calculated
        '''
        result = self._values.get("max_entries")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PrefixListOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PrefixListProps",
    jsii_struct_bases=[PrefixListOptions],
    name_mapping={
        "max_entries": "maxEntries",
        "address_family": "addressFamily",
        "entries": "entries",
        "prefix_list_name": "prefixListName",
    },
)
class PrefixListProps(PrefixListOptions):
    def __init__(
        self,
        *,
        max_entries: typing.Optional[jsii.Number] = None,
        address_family: typing.Optional[AddressFamily] = None,
        entries: typing.Optional[typing.Sequence[typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
        prefix_list_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for creating a prefix list.

        :param max_entries: The maximum number of entries for the prefix list. Default: Automatically-calculated
        :param address_family: The address family of the prefix list. Default: AddressFamily.IP_V4
        :param entries: The list of entries for the prefix list. Default: []
        :param prefix_list_name: The name of the prefix list. Default: None

        :exampleMetadata: infused

        Example::

            ec2.PrefixList(self, "EmptyPrefixList",
                max_entries=100
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__442eb253076fc719267daf436fd1c12e98d31f5ec1af012b1a86fe3e46bd32aa)
            check_type(argname="argument max_entries", value=max_entries, expected_type=type_hints["max_entries"])
            check_type(argname="argument address_family", value=address_family, expected_type=type_hints["address_family"])
            check_type(argname="argument entries", value=entries, expected_type=type_hints["entries"])
            check_type(argname="argument prefix_list_name", value=prefix_list_name, expected_type=type_hints["prefix_list_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if max_entries is not None:
            self._values["max_entries"] = max_entries
        if address_family is not None:
            self._values["address_family"] = address_family
        if entries is not None:
            self._values["entries"] = entries
        if prefix_list_name is not None:
            self._values["prefix_list_name"] = prefix_list_name

    @builtins.property
    def max_entries(self) -> typing.Optional[jsii.Number]:
        '''The maximum number of entries for the prefix list.

        :default: Automatically-calculated
        '''
        result = self._values.get("max_entries")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def address_family(self) -> typing.Optional[AddressFamily]:
        '''The address family of the prefix list.

        :default: AddressFamily.IP_V4
        '''
        result = self._values.get("address_family")
        return typing.cast(typing.Optional[AddressFamily], result)

    @builtins.property
    def entries(self) -> typing.Optional[typing.List[CfnPrefixList.EntryProperty]]:
        '''The list of entries for the prefix list.

        :default: []
        '''
        result = self._values.get("entries")
        return typing.cast(typing.Optional[typing.List[CfnPrefixList.EntryProperty]], result)

    @builtins.property
    def prefix_list_name(self) -> typing.Optional[builtins.str]:
        '''The name of the prefix list.

        :default: None

        :remarks: It is not recommended to use an explicit name.
        '''
        result = self._values.get("prefix_list_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PrefixListProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.Protocol")
class Protocol(enum.Enum):
    '''Protocol for use in Connection Rules.

    https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
    '''

    ALL = "ALL"
    HOPOPT = "HOPOPT"
    ICMP = "ICMP"
    IGMP = "IGMP"
    GGP = "GGP"
    IPV4 = "IPV4"
    ST = "ST"
    TCP = "TCP"
    CBT = "CBT"
    EGP = "EGP"
    IGP = "IGP"
    BBN_RCC_MON = "BBN_RCC_MON"
    NVP_II = "NVP_II"
    PUP = "PUP"
    EMCON = "EMCON"
    XNET = "XNET"
    CHAOS = "CHAOS"
    UDP = "UDP"
    MUX = "MUX"
    DCN_MEAS = "DCN_MEAS"
    HMP = "HMP"
    PRM = "PRM"
    XNS_IDP = "XNS_IDP"
    TRUNK_1 = "TRUNK_1"
    TRUNK_2 = "TRUNK_2"
    LEAF_1 = "LEAF_1"
    LEAF_2 = "LEAF_2"
    RDP = "RDP"
    IRTP = "IRTP"
    ISO_TP4 = "ISO_TP4"
    NETBLT = "NETBLT"
    MFE_NSP = "MFE_NSP"
    MERIT_INP = "MERIT_INP"
    DCCP = "DCCP"
    THREEPC = "THREEPC"
    IDPR = "IDPR"
    XTP = "XTP"
    DDP = "DDP"
    IDPR_CMTP = "IDPR_CMTP"
    TPPLUSPLUS = "TPPLUSPLUS"
    IL = "IL"
    IPV6 = "IPV6"
    SDRP = "SDRP"
    IPV6_ROUTE = "IPV6_ROUTE"
    IPV6_FRAG = "IPV6_FRAG"
    IDRP = "IDRP"
    RSVP = "RSVP"
    GRE = "GRE"
    DSR = "DSR"
    BNA = "BNA"
    ESP = "ESP"
    AH = "AH"
    I_NLSP = "I_NLSP"
    SWIPE = "SWIPE"
    NARP = "NARP"
    MOBILE = "MOBILE"
    TLSP = "TLSP"
    SKIP = "SKIP"
    ICMPV6 = "ICMPV6"
    IPV6_NONXT = "IPV6_NONXT"
    IPV6_OPTS = "IPV6_OPTS"
    CFTP = "CFTP"
    ANY_LOCAL = "ANY_LOCAL"
    SAT_EXPAK = "SAT_EXPAK"
    KRYPTOLAN = "KRYPTOLAN"
    RVD = "RVD"
    IPPC = "IPPC"
    ANY_DFS = "ANY_DFS"
    SAT_MON = "SAT_MON"
    VISA = "VISA"
    IPCV = "IPCV"
    CPNX = "CPNX"
    CPHB = "CPHB"
    WSN = "WSN"
    PVP = "PVP"
    BR_SAT_MON = "BR_SAT_MON"
    SUN_ND = "SUN_ND"
    WB_MON = "WB_MON"
    WB_EXPAK = "WB_EXPAK"
    ISO_IP = "ISO_IP"
    VMTP = "VMTP"
    SECURE_VMTP = "SECURE_VMTP"
    VINES = "VINES"
    TTP = "TTP"
    IPTM = "IPTM"
    NSFNET_IGP = "NSFNET_IGP"
    DGP = "DGP"
    TCF = "TCF"
    EIGRP = "EIGRP"
    OSPFIGP = "OSPFIGP"
    SPRITE_RPC = "SPRITE_RPC"
    LARP = "LARP"
    MTP = "MTP"
    AX_25 = "AX_25"
    IPIP = "IPIP"
    MICP = "MICP"
    SCC_SP = "SCC_SP"
    ETHERIP = "ETHERIP"
    ENCAP = "ENCAP"
    ANY_ENC = "ANY_ENC"
    GMTP = "GMTP"
    IFMP = "IFMP"
    PNNI = "PNNI"
    PIM = "PIM"
    ARIS = "ARIS"
    SCPS = "SCPS"
    QNX = "QNX"
    A_N = "A_N"
    IPCOMP = "IPCOMP"
    SNP = "SNP"
    COMPAQ_PEER = "COMPAQ_PEER"
    IPX_IN_IP = "IPX_IN_IP"
    VRRP = "VRRP"
    PGM = "PGM"
    ANY_0_HOP = "ANY_0_HOP"
    L2_T_P = "L2_T_P"
    DDX = "DDX"
    IATP = "IATP"
    STP = "STP"
    SRP = "SRP"
    UTI = "UTI"
    SMP = "SMP"
    SM = "SM"
    PTP = "PTP"
    ISIS_IPV4 = "ISIS_IPV4"
    FIRE = "FIRE"
    CRTP = "CRTP"
    CRUDP = "CRUDP"
    SSCOPMCE = "SSCOPMCE"
    IPLT = "IPLT"
    SPS = "SPS"
    PIPE = "PIPE"
    SCTP = "SCTP"
    FC = "FC"
    RSVP_E2E_IGNORE = "RSVP_E2E_IGNORE"
    MOBILITY_HEADER = "MOBILITY_HEADER"
    UDPLITE = "UDPLITE"
    MPLS_IN_IP = "MPLS_IN_IP"
    MANET = "MANET"
    HIP = "HIP"
    SHIM6 = "SHIM6"
    WESP = "WESP"
    ROHC = "ROHC"
    ETHERNET = "ETHERNET"
    EXPERIMENT_1 = "EXPERIMENT_1"
    EXPERIMENT_2 = "EXPERIMENT_2"
    RESERVED = "RESERVED"


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.RequestedSubnet",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "configuration": "configuration",
        "subnet_construct_id": "subnetConstructId",
    },
)
class RequestedSubnet:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        configuration: typing.Union["SubnetConfiguration", typing.Dict[builtins.str, typing.Any]],
        subnet_construct_id: builtins.str,
    ) -> None:
        '''Subnet requested for allocation.

        :param availability_zone: The availability zone for the subnet.
        :param configuration: Specify configuration parameters for a single subnet group in a VPC.
        :param subnet_construct_id: Id for the Subnet construct.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            requested_subnet = ec2.RequestedSubnet(
                availability_zone="availabilityZone",
                configuration=ec2.SubnetConfiguration(
                    name="name",
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
            
                    # the properties below are optional
                    cidr_mask=123,
                    ipv6_assign_address_on_creation=False,
                    map_public_ip_on_launch=False,
                    reserved=False
                ),
                subnet_construct_id="subnetConstructId"
            )
        '''
        if isinstance(configuration, dict):
            configuration = SubnetConfiguration(**configuration)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb9c21f15b378acd78737933455e65f7bb8b078652a7ac4ee6c1295016709aab)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
            check_type(argname="argument subnet_construct_id", value=subnet_construct_id, expected_type=type_hints["subnet_construct_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "configuration": configuration,
            "subnet_construct_id": subnet_construct_id,
        }

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The availability zone for the subnet.'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def configuration(self) -> "SubnetConfiguration":
        '''Specify configuration parameters for a single subnet group in a VPC.'''
        result = self._values.get("configuration")
        assert result is not None, "Required property 'configuration' is missing"
        return typing.cast("SubnetConfiguration", result)

    @builtins.property
    def subnet_construct_id(self) -> builtins.str:
        '''Id for the Subnet construct.'''
        result = self._values.get("subnet_construct_id")
        assert result is not None, "Required property 'subnet_construct_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RequestedSubnet(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IMachineImage)
class ResolveSsmParameterAtLaunchImage(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.ResolveSsmParameterAtLaunchImage",
):
    '''Select the image based on a given SSM parameter at instance launch time.

    This Machine Image comes with an imageId as ``resolve:ssm:parameter-name`` or ``resolve:ssm:parameter-name:version`` format
    as described in the document:

    :see:

    https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html

    The AMI ID would be selected at instance launch time.
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # user_data: ec2.UserData
        
        resolve_ssm_parameter_at_launch_image = ec2.ResolveSsmParameterAtLaunchImage("parameterName",
            cached_in_context=False,
            os=ec2.OperatingSystemType.LINUX,
            parameter_version="parameterVersion",
            user_data=user_data
        )
    '''

    def __init__(
        self,
        parameter_name: builtins.str,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        os: typing.Optional[OperatingSystemType] = None,
        parameter_version: typing.Optional[builtins.str] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> None:
        '''
        :param parameter_name: -
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param os: Operating system. Default: OperatingSystemType.LINUX
        :param parameter_version: The version of the SSM parameter. Default: no version specified.
        :param user_data: Custom UserData. Default: - UserData appropriate for the OS
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae85933c688e38a0dd9faa69a685488b55c8c19f918eabcacbd33c964c7bb468)
            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
        props = SsmParameterImageOptions(
            cached_in_context=cached_in_context,
            os=os,
            parameter_version=parameter_version,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [parameter_name, props])

    @jsii.member(jsii_name="getImage")
    def get_image(self, _: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param _: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d20c701794e8ce600958b0084cd7254773f41a44aeda9ef5a9b369a5688d8019)
            check_type(argname="argument _", value=_, expected_type=type_hints["_"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [_]))

    @builtins.property
    @jsii.member(jsii_name="parameterName")
    def parameter_name(self) -> builtins.str:
        '''Name of the SSM parameter we're looking up.'''
        return typing.cast(builtins.str, jsii.get(self, "parameterName"))


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.RouterType")
class RouterType(enum.Enum):
    '''Type of router used in route.

    :exampleMetadata: infused

    Example::

        vpc = ec2.Vpc(self, "VPC",
            subnet_configuration=[ec2.SubnetConfiguration(
                subnet_type=ec2.SubnetType.PUBLIC,
                name="Public"
            ), ec2.SubnetConfiguration(
                subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
                name="Isolated"
            )]
        )
        
        (vpc.isolated_subnets[0]).add_route("StaticRoute",
            router_id=vpc.internet_gateway_id,
            router_type=ec2.RouterType.GATEWAY,
            destination_cidr_block="8.8.8.8/32"
        )
    '''

    CARRIER_GATEWAY = "CARRIER_GATEWAY"
    '''Carrier gateway.'''
    EGRESS_ONLY_INTERNET_GATEWAY = "EGRESS_ONLY_INTERNET_GATEWAY"
    '''Egress-only Internet Gateway.'''
    GATEWAY = "GATEWAY"
    '''Internet Gateway.'''
    INSTANCE = "INSTANCE"
    '''Instance.'''
    LOCAL_GATEWAY = "LOCAL_GATEWAY"
    '''Local Gateway.'''
    NAT_GATEWAY = "NAT_GATEWAY"
    '''NAT Gateway.'''
    NETWORK_INTERFACE = "NETWORK_INTERFACE"
    '''Network Interface.'''
    TRANSIT_GATEWAY = "TRANSIT_GATEWAY"
    '''Transit Gateway.'''
    VPC_PEERING_CONNECTION = "VPC_PEERING_CONNECTION"
    '''VPC peering connection.'''
    VPC_ENDPOINT = "VPC_ENDPOINT"
    '''VPC Endpoint for gateway load balancers.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.RuleScope",
    jsii_struct_bases=[],
    name_mapping={"id": "id", "scope": "scope"},
)
class RuleScope:
    def __init__(self, *, id: builtins.str, scope: ISecurityGroup) -> None:
        '''The scope and id in which a given SecurityGroup rule should be defined.

        :param id: The construct ID to use for the rule.
        :param scope: The SecurityGroup in which a rule should be scoped.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # security_group: ec2.SecurityGroup
            
            rule_scope = ec2.RuleScope(
                id="id",
                scope=security_group
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c97e7361447937a3ff7e70939dab0e82823557a4104f364486155f47ebcb9f5d)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "id": id,
            "scope": scope,
        }

    @builtins.property
    def id(self) -> builtins.str:
        '''The construct ID to use for the rule.'''
        result = self._values.get("id")
        assert result is not None, "Required property 'id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def scope(self) -> ISecurityGroup:
        '''The SecurityGroup in which a rule should be scoped.'''
        result = self._values.get("scope")
        assert result is not None, "Required property 'scope' is missing"
        return typing.cast(ISecurityGroup, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RuleScope(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.S3DestinationOptions",
    jsii_struct_bases=[],
    name_mapping={
        "file_format": "fileFormat",
        "hive_compatible_partitions": "hiveCompatiblePartitions",
        "per_hour_partition": "perHourPartition",
    },
)
class S3DestinationOptions:
    def __init__(
        self,
        *,
        file_format: typing.Optional[FlowLogFileFormat] = None,
        hive_compatible_partitions: typing.Optional[builtins.bool] = None,
        per_hour_partition: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Options for writing logs to a S3 destination.

        :param file_format: The format for the flow log. Default: FlowLogFileFormat.PLAIN_TEXT
        :param hive_compatible_partitions: Use Hive-compatible prefixes for flow logs stored in Amazon S3. Default: false
        :param per_hour_partition: Partition the flow log per hour. Default: false

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            s3_destination_options = ec2.S3DestinationOptions(
                file_format=ec2.FlowLogFileFormat.PLAIN_TEXT,
                hive_compatible_partitions=False,
                per_hour_partition=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a525c7bfcc50f5d3a14f2363920f8474172327e7f9e8077799beb5fe2b32ea9f)
            check_type(argname="argument file_format", value=file_format, expected_type=type_hints["file_format"])
            check_type(argname="argument hive_compatible_partitions", value=hive_compatible_partitions, expected_type=type_hints["hive_compatible_partitions"])
            check_type(argname="argument per_hour_partition", value=per_hour_partition, expected_type=type_hints["per_hour_partition"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if file_format is not None:
            self._values["file_format"] = file_format
        if hive_compatible_partitions is not None:
            self._values["hive_compatible_partitions"] = hive_compatible_partitions
        if per_hour_partition is not None:
            self._values["per_hour_partition"] = per_hour_partition

    @builtins.property
    def file_format(self) -> typing.Optional[FlowLogFileFormat]:
        '''The format for the flow log.

        :default: FlowLogFileFormat.PLAIN_TEXT
        '''
        result = self._values.get("file_format")
        return typing.cast(typing.Optional[FlowLogFileFormat], result)

    @builtins.property
    def hive_compatible_partitions(self) -> typing.Optional[builtins.bool]:
        '''Use Hive-compatible prefixes for flow logs stored in Amazon S3.

        :default: false
        '''
        result = self._values.get("hive_compatible_partitions")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def per_hour_partition(self) -> typing.Optional[builtins.bool]:
        '''Partition the flow log per hour.

        :default: false
        '''
        result = self._values.get("per_hour_partition")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3DestinationOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.S3DownloadOptions",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "bucket_key": "bucketKey",
        "local_file": "localFile",
        "region": "region",
    },
)
class S3DownloadOptions:
    def __init__(
        self,
        *,
        bucket: _IBucket_42e086fd,
        bucket_key: builtins.str,
        local_file: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options when downloading files from S3.

        :param bucket: Name of the S3 bucket to download from.
        :param bucket_key: The key of the file to download.
        :param local_file: The name of the local file. Default: Linux - /tmp/bucketKey Windows - %TEMP%/bucketKey
        :param region: The region of the S3 Bucket (needed for access via VPC Gateway). Default: none

        :exampleMetadata: infused

        Example::

            from aws_cdk.aws_s3_assets import Asset
            
            # instance: ec2.Instance
            
            
            asset = Asset(self, "Asset",
                path="./configure.sh"
            )
            
            local_path = instance.user_data.add_s3_download_command(
                bucket=asset.bucket,
                bucket_key=asset.s3_object_key,
                region="us-east-1"
            )
            instance.user_data.add_execute_file_command(
                file_path=local_path,
                arguments="--verbose -y"
            )
            asset.grant_read(instance.role)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__122958e3ae9e747726b547e8fdf1e540eb62b7085289c54d5c2b8fb6f13b2e3b)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument bucket_key", value=bucket_key, expected_type=type_hints["bucket_key"])
            check_type(argname="argument local_file", value=local_file, expected_type=type_hints["local_file"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "bucket_key": bucket_key,
        }
        if local_file is not None:
            self._values["local_file"] = local_file
        if region is not None:
            self._values["region"] = region

    @builtins.property
    def bucket(self) -> _IBucket_42e086fd:
        '''Name of the S3 bucket to download from.'''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(_IBucket_42e086fd, result)

    @builtins.property
    def bucket_key(self) -> builtins.str:
        '''The key of the file to download.'''
        result = self._values.get("bucket_key")
        assert result is not None, "Required property 'bucket_key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def local_file(self) -> typing.Optional[builtins.str]:
        '''The name of the local file.

        :default:

        Linux   - /tmp/bucketKey
        Windows - %TEMP%/bucketKey
        '''
        result = self._values.get("local_file")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''The region of the S3 Bucket (needed for access via VPC Gateway).

        :default: none
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3DownloadOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ISecurityGroup)
class SecurityGroup(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.SecurityGroup",
):
    '''Creates an Amazon EC2 security group within a VPC.

    Security Groups act like a firewall with a set of rules, and are associated
    with any AWS resource that has or creates Elastic Network Interfaces (ENIs).
    A typical example of a resource that has a security group is an Instance (or
    Auto Scaling Group of instances)

    If you are defining new infrastructure in CDK, there is a good chance you
    won't have to interact with this class at all. Like IAM Roles, Security
    Groups need to exist to control access between AWS resources, but CDK will
    automatically generate and populate them with least-privilege permissions
    for you so you can concentrate on your business logic.

    All Constructs that require Security Groups will create one for you if you
    don't specify one at construction. After construction, you can selectively
    allow connections to and between constructs via--for example-- the ``instance.connections``
    object. Think of it as "allowing connections to your instance", rather than
    "adding ingress rules a security group". See the `Allowing
    Connections <https://docs.aws.amazon.com/cdk/api/latest/docs/aws-cdk-lib.aws_ec2-readme.html#allowing-connections>`_
    section in the library documentation for examples.

    Direct manipulation of the Security Group through ``addIngressRule`` and
    ``addEgressRule`` is possible, but mutation through the ``.connections`` object
    is recommended. If you peer two constructs with security groups this way,
    appropriate rules will be created in both.

    If you have an existing security group you want to use in your CDK application,
    you would import it like this::

       security_group = ec2.SecurityGroup.from_security_group_id(self, "SG", "sg-12345",
           mutable=False
       )

    :exampleMetadata: fixture=with-vpc infused

    Example::

        my_security_group_without_inline_rules = ec2.SecurityGroup(self, "SecurityGroup",
            vpc=vpc,
            description="Allow ssh access to ec2 instances",
            allow_all_outbound=True,
            disable_inline_rules=True
        )
        # This will add the rule as an external cloud formation construct
        my_security_group_without_inline_rules.add_ingress_rule(ec2.Peer.any_ipv4(), ec2.Port.tcp(22), "allow ssh access from the world")
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        disable_inline_rules: typing.Optional[builtins.bool] = None,
        security_group_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC in which to create the security group.
        :param allow_all_ipv6_outbound: Whether to allow all outbound ipv6 traffic by default. If this is set to true, there will only be a single egress rule which allows all outbound ipv6 traffic. If this is set to false, no outbound traffic will be allowed by default and all egress ipv6 traffic must be explicitly authorized. To allow all ipv4 traffic use allowAllOutbound Default: false
        :param allow_all_outbound: Whether to allow all outbound traffic by default. If this is set to true, there will only be a single egress rule which allows all outbound traffic. If this is set to false, no outbound traffic will be allowed by default and all egress traffic must be explicitly authorized. To allow all ipv6 traffic use allowAllIpv6Outbound Default: true
        :param description: A description of the security group. Default: The default name will be the construct's CDK path.
        :param disable_inline_rules: Whether to disable inline ingress and egress rule optimization. If this is set to true, ingress and egress rules will not be declared under the SecurityGroup in cloudformation, but will be separate elements. Inlining rules is an optimization for producing smaller stack templates. Sometimes this is not desirable, for example when security group access is managed via tags. The default value can be overriden globally by setting the context variable '@aws-cdk/aws-ec2.securityGroupDisableInlineRules'. Default: false
        :param security_group_name: The name of the security group. For valid values, see the GroupName parameter of the CreateSecurityGroup action in the Amazon EC2 API Reference. It is not recommended to use an explicit group name. Default: If you don't specify a GroupName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__316108b6f1bf79b7e133269b99dee1a1a6a63cd0fe7b2ee4fc28ee2cf4ecc838)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = SecurityGroupProps(
            vpc=vpc,
            allow_all_ipv6_outbound=allow_all_ipv6_outbound,
            allow_all_outbound=allow_all_outbound,
            description=description,
            disable_inline_rules=disable_inline_rules,
            security_group_name=security_group_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromLookupById")
    @builtins.classmethod
    def from_lookup_by_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        security_group_id: builtins.str,
    ) -> ISecurityGroup:
        '''Look up a security group by id.

        :param scope: -
        :param id: -
        :param security_group_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__268af46e9b96e4963a9f2edc9cdca4f851f7ffad8efe5094fca1c65650100020)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
        return typing.cast(ISecurityGroup, jsii.sinvoke(cls, "fromLookupById", [scope, id, security_group_id]))

    @jsii.member(jsii_name="fromLookupByName")
    @builtins.classmethod
    def from_lookup_by_name(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        security_group_name: builtins.str,
        vpc: IVpc,
    ) -> ISecurityGroup:
        '''Look up a security group by name.

        :param scope: -
        :param id: -
        :param security_group_name: -
        :param vpc: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38fa12ff9b16d1c8aab7f5c824213d7c1405eb244c7b2e0b25fc8b85d015a674)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument security_group_name", value=security_group_name, expected_type=type_hints["security_group_name"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        return typing.cast(ISecurityGroup, jsii.sinvoke(cls, "fromLookupByName", [scope, id, security_group_name, vpc]))

    @jsii.member(jsii_name="fromSecurityGroupId")
    @builtins.classmethod
    def from_security_group_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        security_group_id: builtins.str,
        *,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        mutable: typing.Optional[builtins.bool] = None,
    ) -> ISecurityGroup:
        '''Import an existing security group into this app.

        This method will assume that the Security Group has a rule in it which allows
        all outbound traffic, and so will not add egress rules to the imported Security
        Group (only ingress rules).

        If your existing Security Group needs to have egress rules added, pass the
        ``allowAllOutbound: false`` option on import.

        :param scope: -
        :param id: -
        :param security_group_id: -
        :param allow_all_ipv6_outbound: Mark the SecurityGroup as having been created allowing all outbound ipv6 traffic. Only if this is set to false will egress rules for ipv6 be added to this security group. Be aware, this would undo any potential "all outbound traffic" default. Default: false
        :param allow_all_outbound: Mark the SecurityGroup as having been created allowing all outbound traffic. Only if this is set to false will egress rules be added to this security group. Be aware, this would undo any potential "all outbound traffic" default. Default: true
        :param mutable: If a SecurityGroup is mutable CDK can add rules to existing groups. Beware that making a SecurityGroup immutable might lead to issue due to missing ingress/egress rules for new resources. Default: true
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a078d45d43fdc6c29660bfbfdddf1bc2bd2b473230637a5526efa3841492963b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
        options = SecurityGroupImportOptions(
            allow_all_ipv6_outbound=allow_all_ipv6_outbound,
            allow_all_outbound=allow_all_outbound,
            mutable=mutable,
        )

        return typing.cast(ISecurityGroup, jsii.sinvoke(cls, "fromSecurityGroupId", [scope, id, security_group_id, options]))

    @jsii.member(jsii_name="isSecurityGroup")
    @builtins.classmethod
    def is_security_group(cls, x: typing.Any) -> builtins.bool:
        '''Return whether the indicated object is a security group.

        :param x: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__240ff3afc3b80af7aa57f8b5c2eff20d2f7af102addb8cf282ca2922f6ceb71f)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isSecurityGroup", [x]))

    @jsii.member(jsii_name="addEgressRule")
    def add_egress_rule(
        self,
        peer: IPeer,
        connection: Port,
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an egress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5c1db93dd7916ef933c13786d55d666b796d56418454500ce1225cb4d24f9c39)
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument remote_rule", value=remote_rule, expected_type=type_hints["remote_rule"])
        return typing.cast(None, jsii.invoke(self, "addEgressRule", [peer, connection, description, remote_rule]))

    @jsii.member(jsii_name="addIngressRule")
    def add_ingress_rule(
        self,
        peer: IPeer,
        connection: Port,
        description: typing.Optional[builtins.str] = None,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Add an ingress rule for the current security group.

        ``remoteRule`` controls where the Rule object is created if the peer is also a
        securityGroup and they are in different stack. If false (default) the
        rule object is created under the current SecurityGroup object. If true and the
        peer is also a SecurityGroup, the rule object is created under the remote
        SecurityGroup object.

        :param peer: -
        :param connection: -
        :param description: -
        :param remote_rule: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00557fc963b656805c2728b899d2a52811fe0eb30b79019e9e64bae9a39d0b86)
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument remote_rule", value=remote_rule, expected_type=type_hints["remote_rule"])
        return typing.cast(None, jsii.invoke(self, "addIngressRule", [peer, connection, description, remote_rule]))

    @jsii.member(jsii_name="determineRuleScope")
    def _determine_rule_scope(
        self,
        peer: IPeer,
        connection: Port,
        from_to: builtins.str,
        remote_rule: typing.Optional[builtins.bool] = None,
    ) -> RuleScope:
        '''Determine where to parent a new ingress/egress rule.

        A SecurityGroup rule is parented under the group it's related to, UNLESS
        we're in a cross-stack scenario with another Security Group. In that case,
        we respect the 'remoteRule' flag and will parent under the other security
        group.

        This is necessary to avoid cyclic dependencies between stacks, since both
        ingress and egress rules will reference both security groups, and a naive
        parenting will lead to the following situation:

        ╔════════════════════╗         ╔════════════════════╗
        ║  ┌───────────┐     ║         ║    ┌───────────┐   ║
        ║  │  GroupA   │◀────╬─┐   ┌───╬───▶│  GroupB   │   ║
        ║  └───────────┘     ║ │   │   ║    └───────────┘   ║
        ║        ▲           ║ │   │   ║          ▲         ║
        ║        │           ║ │   │   ║          │         ║
        ║        │           ║ │   │   ║          │         ║
        ║  ┌───────────┐     ║ └───┼───╬────┌───────────┐   ║
        ║  │  EgressA  │─────╬─────┘   ║    │ IngressB  │   ║
        ║  └───────────┘     ║         ║    └───────────┘   ║
        ║                    ║         ║                    ║
        ╚════════════════════╝         ╚════════════════════╝

        By having the ability to switch the parent, we avoid the cyclic reference by
        keeping all rules in a single stack.

        If this happens, we also have to change the construct ID, because
        otherwise we might have two objects with the same ID if we have
        multiple reversed security group relationships.

        ╔═══════════════════════════════════╗
        ║┌───────────┐                      ║
        ║│  GroupB   │                      ║
        ║└───────────┘                      ║
        ║      ▲                            ║
        ║      │              ┌───────────┐ ║
        ║      ├────"from A"──│ IngressB  │ ║
        ║      │              └───────────┘ ║
        ║      │              ┌───────────┐ ║
        ║      ├─────"to B"───│  EgressA  │ ║
        ║      │              └───────────┘ ║
        ║      │              ┌───────────┐ ║
        ║      └─────"to B"───│  EgressC  │ ║  <-- oops
        ║                     └───────────┘ ║
        ╚═══════════════════════════════════╝

        :param peer: -
        :param connection: -
        :param from_to: -
        :param remote_rule: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9f9ad9749c7ef65867bc96b83aeacb3340670b7f57e4d710e42938a9151be29b)
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
            check_type(argname="argument connection", value=connection, expected_type=type_hints["connection"])
            check_type(argname="argument from_to", value=from_to, expected_type=type_hints["from_to"])
            check_type(argname="argument remote_rule", value=remote_rule, expected_type=type_hints["remote_rule"])
        return typing.cast(RuleScope, jsii.invoke(self, "determineRuleScope", [peer, connection, from_to, remote_rule]))

    @jsii.member(jsii_name="toEgressRuleConfig")
    def to_egress_rule_config(self) -> typing.Any:
        '''Produce the egress rule JSON for the given connection.'''
        return typing.cast(typing.Any, jsii.invoke(self, "toEgressRuleConfig", []))

    @jsii.member(jsii_name="toIngressRuleConfig")
    def to_ingress_rule_config(self) -> typing.Any:
        '''Produce the ingress rule JSON for the given connection.'''
        return typing.cast(typing.Any, jsii.invoke(self, "toIngressRuleConfig", []))

    @builtins.property
    @jsii.member(jsii_name="allowAllIpv6Outbound")
    def allow_all_ipv6_outbound(self) -> builtins.bool:
        '''Whether the SecurityGroup has been configured to allow all outbound ipv6 traffic.'''
        return typing.cast(builtins.bool, jsii.get(self, "allowAllIpv6Outbound"))

    @builtins.property
    @jsii.member(jsii_name="allowAllOutbound")
    def allow_all_outbound(self) -> builtins.bool:
        '''Whether the SecurityGroup has been configured to allow all outbound traffic.'''
        return typing.cast(builtins.bool, jsii.get(self, "allowAllOutbound"))

    @builtins.property
    @jsii.member(jsii_name="canInlineRule")
    def can_inline_rule(self) -> builtins.bool:
        '''Whether the rule can be inlined into a SecurityGroup or not.'''
        return typing.cast(builtins.bool, jsii.get(self, "canInlineRule"))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''The network connections associated with this resource.'''
        return typing.cast("Connections", jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="securityGroupId")
    def security_group_id(self) -> builtins.str:
        '''The ID of the security group.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "securityGroupId"))

    @builtins.property
    @jsii.member(jsii_name="securityGroupVpcId")
    def security_group_vpc_id(self) -> builtins.str:
        '''The VPC ID this security group is part of.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "securityGroupVpcId"))

    @builtins.property
    @jsii.member(jsii_name="uniqueId")
    def unique_id(self) -> builtins.str:
        '''A unique identifier for this connection peer.'''
        return typing.cast(builtins.str, jsii.get(self, "uniqueId"))

    @builtins.property
    @jsii.member(jsii_name="defaultPort")
    def default_port(self) -> typing.Optional[Port]:
        return typing.cast(typing.Optional[Port], jsii.get(self, "defaultPort"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SecurityGroupImportOptions",
    jsii_struct_bases=[],
    name_mapping={
        "allow_all_ipv6_outbound": "allowAllIpv6Outbound",
        "allow_all_outbound": "allowAllOutbound",
        "mutable": "mutable",
    },
)
class SecurityGroupImportOptions:
    def __init__(
        self,
        *,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        mutable: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Additional options for imported security groups.

        :param allow_all_ipv6_outbound: Mark the SecurityGroup as having been created allowing all outbound ipv6 traffic. Only if this is set to false will egress rules for ipv6 be added to this security group. Be aware, this would undo any potential "all outbound traffic" default. Default: false
        :param allow_all_outbound: Mark the SecurityGroup as having been created allowing all outbound traffic. Only if this is set to false will egress rules be added to this security group. Be aware, this would undo any potential "all outbound traffic" default. Default: true
        :param mutable: If a SecurityGroup is mutable CDK can add rules to existing groups. Beware that making a SecurityGroup immutable might lead to issue due to missing ingress/egress rules for new resources. Default: true

        :exampleMetadata: infused

        Example::

            security_group = ec2.SecurityGroup.from_security_group_id(self, "SG", "sg-12345",
                mutable=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d865607edfe09cbfe02f00518db09c521f9beeb5a40df2759334573b346f6a5a)
            check_type(argname="argument allow_all_ipv6_outbound", value=allow_all_ipv6_outbound, expected_type=type_hints["allow_all_ipv6_outbound"])
            check_type(argname="argument allow_all_outbound", value=allow_all_outbound, expected_type=type_hints["allow_all_outbound"])
            check_type(argname="argument mutable", value=mutable, expected_type=type_hints["mutable"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if allow_all_ipv6_outbound is not None:
            self._values["allow_all_ipv6_outbound"] = allow_all_ipv6_outbound
        if allow_all_outbound is not None:
            self._values["allow_all_outbound"] = allow_all_outbound
        if mutable is not None:
            self._values["mutable"] = mutable

    @builtins.property
    def allow_all_ipv6_outbound(self) -> typing.Optional[builtins.bool]:
        '''Mark the SecurityGroup as having been created allowing all outbound ipv6 traffic.

        Only if this is set to false will egress rules for ipv6 be added to this security
        group. Be aware, this would undo any potential "all outbound traffic"
        default.

        :default: false
        '''
        result = self._values.get("allow_all_ipv6_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def allow_all_outbound(self) -> typing.Optional[builtins.bool]:
        '''Mark the SecurityGroup as having been created allowing all outbound traffic.

        Only if this is set to false will egress rules be added to this security
        group. Be aware, this would undo any potential "all outbound traffic"
        default.

        :default: true
        '''
        result = self._values.get("allow_all_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def mutable(self) -> typing.Optional[builtins.bool]:
        '''If a SecurityGroup is mutable CDK can add rules to existing groups.

        Beware that making a SecurityGroup immutable might lead to issue
        due to missing ingress/egress rules for new resources.

        :default: true
        '''
        result = self._values.get("mutable")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecurityGroupImportOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SecurityGroupProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc": "vpc",
        "allow_all_ipv6_outbound": "allowAllIpv6Outbound",
        "allow_all_outbound": "allowAllOutbound",
        "description": "description",
        "disable_inline_rules": "disableInlineRules",
        "security_group_name": "securityGroupName",
    },
)
class SecurityGroupProps:
    def __init__(
        self,
        *,
        vpc: IVpc,
        allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
        allow_all_outbound: typing.Optional[builtins.bool] = None,
        description: typing.Optional[builtins.str] = None,
        disable_inline_rules: typing.Optional[builtins.bool] = None,
        security_group_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param vpc: The VPC in which to create the security group.
        :param allow_all_ipv6_outbound: Whether to allow all outbound ipv6 traffic by default. If this is set to true, there will only be a single egress rule which allows all outbound ipv6 traffic. If this is set to false, no outbound traffic will be allowed by default and all egress ipv6 traffic must be explicitly authorized. To allow all ipv4 traffic use allowAllOutbound Default: false
        :param allow_all_outbound: Whether to allow all outbound traffic by default. If this is set to true, there will only be a single egress rule which allows all outbound traffic. If this is set to false, no outbound traffic will be allowed by default and all egress traffic must be explicitly authorized. To allow all ipv6 traffic use allowAllIpv6Outbound Default: true
        :param description: A description of the security group. Default: The default name will be the construct's CDK path.
        :param disable_inline_rules: Whether to disable inline ingress and egress rule optimization. If this is set to true, ingress and egress rules will not be declared under the SecurityGroup in cloudformation, but will be separate elements. Inlining rules is an optimization for producing smaller stack templates. Sometimes this is not desirable, for example when security group access is managed via tags. The default value can be overriden globally by setting the context variable '@aws-cdk/aws-ec2.securityGroupDisableInlineRules'. Default: false
        :param security_group_name: The name of the security group. For valid values, see the GroupName parameter of the CreateSecurityGroup action in the Amazon EC2 API Reference. It is not recommended to use an explicit group name. Default: If you don't specify a GroupName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            
            security_group1 = ec2.SecurityGroup(self, "SecurityGroup1", vpc=vpc)
            lb = elbv2.ApplicationLoadBalancer(self, "LB",
                vpc=vpc,
                internet_facing=True,
                security_group=security_group1
            )
            
            security_group2 = ec2.SecurityGroup(self, "SecurityGroup2", vpc=vpc)
            lb.add_security_group(security_group2)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e55e0c52b51f92e83b1f8d6b7a5b22268d0369a14dab808b8f2f5f233e5b622)
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument allow_all_ipv6_outbound", value=allow_all_ipv6_outbound, expected_type=type_hints["allow_all_ipv6_outbound"])
            check_type(argname="argument allow_all_outbound", value=allow_all_outbound, expected_type=type_hints["allow_all_outbound"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument disable_inline_rules", value=disable_inline_rules, expected_type=type_hints["disable_inline_rules"])
            check_type(argname="argument security_group_name", value=security_group_name, expected_type=type_hints["security_group_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc": vpc,
        }
        if allow_all_ipv6_outbound is not None:
            self._values["allow_all_ipv6_outbound"] = allow_all_ipv6_outbound
        if allow_all_outbound is not None:
            self._values["allow_all_outbound"] = allow_all_outbound
        if description is not None:
            self._values["description"] = description
        if disable_inline_rules is not None:
            self._values["disable_inline_rules"] = disable_inline_rules
        if security_group_name is not None:
            self._values["security_group_name"] = security_group_name

    @builtins.property
    def vpc(self) -> IVpc:
        '''The VPC in which to create the security group.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast(IVpc, result)

    @builtins.property
    def allow_all_ipv6_outbound(self) -> typing.Optional[builtins.bool]:
        '''Whether to allow all outbound ipv6 traffic by default.

        If this is set to true, there will only be a single egress rule which allows all
        outbound ipv6 traffic. If this is set to false, no outbound traffic will be allowed by
        default and all egress ipv6 traffic must be explicitly authorized.

        To allow all ipv4 traffic use allowAllOutbound

        :default: false
        '''
        result = self._values.get("allow_all_ipv6_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def allow_all_outbound(self) -> typing.Optional[builtins.bool]:
        '''Whether to allow all outbound traffic by default.

        If this is set to true, there will only be a single egress rule which allows all
        outbound traffic. If this is set to false, no outbound traffic will be allowed by
        default and all egress traffic must be explicitly authorized.

        To allow all ipv6 traffic use allowAllIpv6Outbound

        :default: true
        '''
        result = self._values.get("allow_all_outbound")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description of the security group.

        :default: The default name will be the construct's CDK path.
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def disable_inline_rules(self) -> typing.Optional[builtins.bool]:
        '''Whether to disable inline ingress and egress rule optimization.

        If this is set to true, ingress and egress rules will not be declared under the
        SecurityGroup in cloudformation, but will be separate elements.

        Inlining rules is an optimization for producing smaller stack templates. Sometimes
        this is not desirable, for example when security group access is managed via tags.

        The default value can be overriden globally by setting the context variable
        '@aws-cdk/aws-ec2.securityGroupDisableInlineRules'.

        :default: false
        '''
        result = self._values.get("disable_inline_rules")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def security_group_name(self) -> typing.Optional[builtins.str]:
        '''The name of the security group.

        For valid values, see the GroupName
        parameter of the CreateSecurityGroup action in the Amazon EC2 API
        Reference.

        It is not recommended to use an explicit group name.

        :default:

        If you don't specify a GroupName, AWS CloudFormation generates a
        unique physical ID and uses that ID for the group name.
        '''
        result = self._values.get("security_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SecurityGroupProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SelectedSubnets",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zones": "availabilityZones",
        "has_public": "hasPublic",
        "internet_connectivity_established": "internetConnectivityEstablished",
        "subnet_ids": "subnetIds",
        "subnets": "subnets",
        "is_pending_lookup": "isPendingLookup",
    },
)
class SelectedSubnets:
    def __init__(
        self,
        *,
        availability_zones: typing.Sequence[builtins.str],
        has_public: builtins.bool,
        internet_connectivity_established: _constructs_77d1e7e8.IDependable,
        subnet_ids: typing.Sequence[builtins.str],
        subnets: typing.Sequence[ISubnet],
        is_pending_lookup: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Result of selecting a subset of subnets from a VPC.

        :param availability_zones: The respective AZs of each subnet.
        :param has_public: Whether any of the given subnets are from the VPC's public subnets.
        :param internet_connectivity_established: Dependency representing internet connectivity for these subnets.
        :param subnet_ids: The subnet IDs.
        :param subnets: Selected subnet objects.
        :param is_pending_lookup: The subnet selection is not actually real yet. If this value is true, don't validate anything about the subnets. The count or identities are not known yet, and the validation will most likely fail which will prevent a successful lookup. Default: false

        :exampleMetadata: infused

        Example::

            vpc = ec2.Vpc(self, "TheVPC",
                ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/16")
            )
            
            # Iterate the private subnets
            selection = vpc.select_subnets(
                subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
            )
            
            for subnet in selection.subnets:
                pass
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__238a040275c82fe5911f2f1fd16a54d47e5937007b9647e86fefb63d03ed2300)
            check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
            check_type(argname="argument has_public", value=has_public, expected_type=type_hints["has_public"])
            check_type(argname="argument internet_connectivity_established", value=internet_connectivity_established, expected_type=type_hints["internet_connectivity_established"])
            check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
            check_type(argname="argument is_pending_lookup", value=is_pending_lookup, expected_type=type_hints["is_pending_lookup"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zones": availability_zones,
            "has_public": has_public,
            "internet_connectivity_established": internet_connectivity_established,
            "subnet_ids": subnet_ids,
            "subnets": subnets,
        }
        if is_pending_lookup is not None:
            self._values["is_pending_lookup"] = is_pending_lookup

    @builtins.property
    def availability_zones(self) -> typing.List[builtins.str]:
        '''The respective AZs of each subnet.'''
        result = self._values.get("availability_zones")
        assert result is not None, "Required property 'availability_zones' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def has_public(self) -> builtins.bool:
        '''Whether any of the given subnets are from the VPC's public subnets.'''
        result = self._values.get("has_public")
        assert result is not None, "Required property 'has_public' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependency representing internet connectivity for these subnets.'''
        result = self._values.get("internet_connectivity_established")
        assert result is not None, "Required property 'internet_connectivity_established' is missing"
        return typing.cast(_constructs_77d1e7e8.IDependable, result)

    @builtins.property
    def subnet_ids(self) -> typing.List[builtins.str]:
        '''The subnet IDs.'''
        result = self._values.get("subnet_ids")
        assert result is not None, "Required property 'subnet_ids' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def subnets(self) -> typing.List[ISubnet]:
        '''Selected subnet objects.'''
        result = self._values.get("subnets")
        assert result is not None, "Required property 'subnets' is missing"
        return typing.cast(typing.List[ISubnet], result)

    @builtins.property
    def is_pending_lookup(self) -> typing.Optional[builtins.bool]:
        '''The subnet selection is not actually real yet.

        If this value is true, don't validate anything about the subnets. The count
        or identities are not known yet, and the validation will most likely fail
        which will prevent a successful lookup.

        :default: false
        '''
        result = self._values.get("is_pending_lookup")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SelectedSubnets(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.ServiceManager")
class ServiceManager(enum.Enum):
    '''The service manager that will be used by InitServices.

    The value needs to match the service manager used by your operating
    system.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        # instance_type: ec2.InstanceType
        
        
        ec2.Instance(self, "Instance",
            vpc=vpc,
            instance_type=instance_type,
            machine_image=ec2.MachineImage.latest_amazon_linux2023(),
        
            init=ec2.CloudFormationInit.from_elements(
                # Create a simple config file that runs a Python web server
                ec2.InitService.systemd_config_file("simpleserver",
                    command="/usr/bin/python3 -m http.server 8080",
                    cwd="/var/www/html"
                ),
                # Start the server using SystemD
                ec2.InitService.enable("simpleserver",
                    service_manager=ec2.ServiceManager.SYSTEMD
                ),
                # Drop an example file to show the web server working
                ec2.InitFile.from_string("/var/www/html/index.html", "Hello! It's working!"))
        )
    '''

    SYSVINIT = "SYSVINIT"
    '''Use SysVinit.

    This is the default for Linux systems.
    '''
    WINDOWS = "WINDOWS"
    '''Use Windows.

    This is the default for Windows systems.
    '''
    SYSTEMD = "SYSTEMD"
    '''Use systemd.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.SpotInstanceInterruption")
class SpotInstanceInterruption(enum.Enum):
    '''Provides the options for the types of interruption for spot instances.'''

    STOP = "STOP"
    '''The instance will stop when interrupted.'''
    TERMINATE = "TERMINATE"
    '''The instance will be terminated when interrupted.'''
    HIBERNATE = "HIBERNATE"
    '''The instance will hibernate when interrupted.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.SpotRequestType")
class SpotRequestType(enum.Enum):
    '''The Spot Instance request type.

    :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html
    '''

    ONE_TIME = "ONE_TIME"
    '''A one-time Spot Instance request remains active until Amazon EC2 launches the Spot Instance, the request expires, or you cancel the request.

    If the Spot price exceeds your maximum price
    or capacity is not available, your Spot Instance is terminated and the Spot Instance request
    is closed.
    '''
    PERSISTENT = "PERSISTENT"
    '''A persistent Spot Instance request remains active until it expires or you cancel it, even if the request is fulfilled.

    If the Spot price exceeds your maximum price or capacity is not available,
    your Spot Instance is interrupted. After your instance is interrupted, when your maximum price exceeds
    the Spot price or capacity becomes available again, the Spot Instance is started if stopped or resumed
    if hibernated.
    '''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SsmParameterImageOptions",
    jsii_struct_bases=[],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "os": "os",
        "parameter_version": "parameterVersion",
        "user_data": "userData",
    },
)
class SsmParameterImageOptions:
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        os: typing.Optional[OperatingSystemType] = None,
        parameter_version: typing.Optional[builtins.str] = None,
        user_data: typing.Optional["UserData"] = None,
    ) -> None:
        '''Properties for GenericSsmParameterImage.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param os: Operating system. Default: OperatingSystemType.LINUX
        :param parameter_version: The version of the SSM parameter. Default: no version specified.
        :param user_data: Custom UserData. Default: - UserData appropriate for the OS

        :exampleMetadata: lit=aws-ec2/test/example.images.lit.ts infused

        Example::

            # Pick the right Amazon Linux edition. All arguments shown are optional
            # and will default to these values when omitted.
            amzn_linux = ec2.MachineImage.latest_amazon_linux(
                generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
                edition=ec2.AmazonLinuxEdition.STANDARD,
                virtualization=ec2.AmazonLinuxVirt.HVM,
                storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE,
                cpu_type=ec2.AmazonLinuxCpuType.X86_64
            )
            
            # Pick a Windows edition to use
            windows = ec2.MachineImage.latest_windows(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
            
            # Read AMI id from SSM parameter store
            ssm = ec2.MachineImage.from_ssm_parameter("/my/ami", os=ec2.OperatingSystemType.LINUX)
            
            # Look up the most recent image matching a set of AMI filters.
            # In this case, look up the NAT instance AMI, by using a wildcard
            # in the 'name' field:
            nat_ami = ec2.MachineImage.lookup(
                name="amzn-ami-vpc-nat-*",
                owners=["amazon"]
            )
            
            # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
            # a map giving the AMI to in for each region:
            linux = ec2.MachineImage.generic_linux({
                "us-east-1": "ami-97785bed",
                "eu-west-1": "ami-12345678"
            })
            
            # For other custom (Windows) images, instantiate a `GenericWindowsImage` with
            # a map giving the AMI to in for each region:
            generic_windows = ec2.MachineImage.generic_windows({
                "us-east-1": "ami-97785bed",
                "eu-west-1": "ami-12345678"
            })
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a03f16dc6f5eb3eb6f69587f84001af20bc314a1c46a530aa5fb21da814be237)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument os", value=os, expected_type=type_hints["os"])
            check_type(argname="argument parameter_version", value=parameter_version, expected_type=type_hints["parameter_version"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if os is not None:
            self._values["os"] = os
        if parameter_version is not None:
            self._values["parameter_version"] = parameter_version
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def os(self) -> typing.Optional[OperatingSystemType]:
        '''Operating system.

        :default: OperatingSystemType.LINUX
        '''
        result = self._values.get("os")
        return typing.cast(typing.Optional[OperatingSystemType], result)

    @builtins.property
    def parameter_version(self) -> typing.Optional[builtins.str]:
        '''The version of the SSM parameter.

        :default: no version specified.
        '''
        result = self._values.get("parameter_version")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def user_data(self) -> typing.Optional["UserData"]:
        '''Custom UserData.

        :default: - UserData appropriate for the OS
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional["UserData"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SsmParameterImageOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ISubnet)
class Subnet(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.Subnet",
):
    '''Represents a new VPC subnet resource.

    :resource: AWS::EC2::Subnet
    :exampleMetadata: infused

    Example::

        # cluster: ecs.Cluster
        
        load_balanced_fargate_service = ecs_patterns.ApplicationLoadBalancedFargateService(self, "Service",
            cluster=cluster,
            memory_limit_mi_b=1024,
            desired_count=1,
            cpu=512,
            task_image_options=ecsPatterns.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
            ),
            task_subnets=ec2.SubnetSelection(
                subnets=[ec2.Subnet.from_subnet_id(self, "subnet", "VpcISOLATEDSubnet1Subnet80F07FA0")]
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96072781b517bff13ac37560a4395f3f40d7b0ddea760cef61d9cf1cadd71151)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = SubnetProps(
            availability_zone=availability_zone,
            cidr_block=cidr_block,
            vpc_id=vpc_id,
            assign_ipv6_address_on_creation=assign_ipv6_address_on_creation,
            ipv6_cidr_block=ipv6_cidr_block,
            map_public_ip_on_launch=map_public_ip_on_launch,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromSubnetAttributes")
    @builtins.classmethod
    def from_subnet_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> ISubnet:
        '''
        :param scope: -
        :param id: -
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd74cec2b1d008b5efda354bf45e7106f5e4cc40bdeb4b483518f394bbc85818)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = SubnetAttributes(
            subnet_id=subnet_id,
            availability_zone=availability_zone,
            ipv4_cidr_block=ipv4_cidr_block,
            route_table_id=route_table_id,
        )

        return typing.cast(ISubnet, jsii.sinvoke(cls, "fromSubnetAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="fromSubnetId")
    @builtins.classmethod
    def from_subnet_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        subnet_id: builtins.str,
    ) -> ISubnet:
        '''Import existing subnet from id.

        :param scope: -
        :param id: -
        :param subnet_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__686b32c9bead2f02f09e3359b02a5598c800bd8b62c5ea3d65e96c536ba974b2)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
        return typing.cast(ISubnet, jsii.sinvoke(cls, "fromSubnetId", [scope, id, subnet_id]))

    @jsii.member(jsii_name="isVpcSubnet")
    @builtins.classmethod
    def is_vpc_subnet(cls, x: typing.Any) -> builtins.bool:
        '''
        :param x: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__68f9347923f1a25d2e9a24cbb80147f5a06b7a1b2d7da6fa137314a0dd5dd1c8)
            check_type(argname="argument x", value=x, expected_type=type_hints["x"])
        return typing.cast(builtins.bool, jsii.sinvoke(cls, "isVpcSubnet", [x]))

    @jsii.member(jsii_name="addDefaultInternetRoute")
    def add_default_internet_route(
        self,
        gateway_id: builtins.str,
        gateway_attachment: _constructs_77d1e7e8.IDependable,
    ) -> None:
        '''Create a default route that points to a passed IGW, with a dependency on the IGW's attachment to the VPC.

        :param gateway_id: the logical ID (ref) of the gateway attached to your VPC.
        :param gateway_attachment: the gateway attachment construct to be added as a dependency.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec97f6f4a7083cd7c7886bd11d04e68a8da20aebc0d822db375888865588961f)
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
            check_type(argname="argument gateway_attachment", value=gateway_attachment, expected_type=type_hints["gateway_attachment"])
        return typing.cast(None, jsii.invoke(self, "addDefaultInternetRoute", [gateway_id, gateway_attachment]))

    @jsii.member(jsii_name="addDefaultNatRoute")
    def add_default_nat_route(self, nat_gateway_id: builtins.str) -> None:
        '''Adds an entry to this subnets route table that points to the passed NATGatewayId.

        :param nat_gateway_id: The ID of the NAT gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__683798bf23eef11df854e359c1532c285ed30544a6a4250fd2ffd6453c7661ab)
            check_type(argname="argument nat_gateway_id", value=nat_gateway_id, expected_type=type_hints["nat_gateway_id"])
        return typing.cast(None, jsii.invoke(self, "addDefaultNatRoute", [nat_gateway_id]))

    @jsii.member(jsii_name="addIpv6DefaultEgressOnlyInternetRoute")
    def add_ipv6_default_egress_only_internet_route(
        self,
        gateway_id: builtins.str,
    ) -> None:
        '''Create a default IPv6 route that points to a passed EIGW.

        :param gateway_id: the logical ID (ref) of the gateway attached to your VPC.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f8943f73ff6d17253f380b241cd0e184164b63a7258c7e4f2916266fe31fd6d5)
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
        return typing.cast(None, jsii.invoke(self, "addIpv6DefaultEgressOnlyInternetRoute", [gateway_id]))

    @jsii.member(jsii_name="addIpv6DefaultInternetRoute")
    def add_ipv6_default_internet_route(self, gateway_id: builtins.str) -> None:
        '''Create a default IPv6 route that points to a passed IGW.

        :param gateway_id: the logical ID (ref) of the gateway attached to your VPC.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__db7827d176dd32691ebb47dcfd1696462acd0dc0cf71a27c9a86164bddc9167a)
            check_type(argname="argument gateway_id", value=gateway_id, expected_type=type_hints["gateway_id"])
        return typing.cast(None, jsii.invoke(self, "addIpv6DefaultInternetRoute", [gateway_id]))

    @jsii.member(jsii_name="addIpv6Nat64Route")
    def add_ipv6_nat64_route(self, nat_gateway_id: builtins.str) -> None:
        '''Adds an entry to this subnets route table that points to the passed NATGatewayId.

        Uses the known 64:ff9b::/96 prefix.

        :param nat_gateway_id: The ID of the NAT gateway.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ee90202f245f7f07ed5e535b7601bd31b62277991dd549319721b802a04128ee)
            check_type(argname="argument nat_gateway_id", value=nat_gateway_id, expected_type=type_hints["nat_gateway_id"])
        return typing.cast(None, jsii.invoke(self, "addIpv6Nat64Route", [nat_gateway_id]))

    @jsii.member(jsii_name="addRoute")
    def add_route(
        self,
        id: builtins.str,
        *,
        router_id: builtins.str,
        router_type: RouterType,
        destination_cidr_block: typing.Optional[builtins.str] = None,
        destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
        enables_internet_connectivity: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Adds an entry to this subnets route table.

        :param id: -
        :param router_id: The ID of the router. Can be an instance ID, gateway ID, etc, depending on the router type.
        :param router_type: What type of router to route this traffic to.
        :param destination_cidr_block: IPv4 range this route applies to. Default: '0.0.0.0/0'
        :param destination_ipv6_cidr_block: IPv6 range this route applies to. Default: - Uses IPv6
        :param enables_internet_connectivity: Whether this route will enable internet connectivity. If true, this route will be added before any AWS resources that depend on internet connectivity in the VPC will be created. Default: false
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__143de5737ac438372990371c031b759c0661edce7c56870abee6bae588471330)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = AddRouteOptions(
            router_id=router_id,
            router_type=router_type,
            destination_cidr_block=destination_cidr_block,
            destination_ipv6_cidr_block=destination_ipv6_cidr_block,
            enables_internet_connectivity=enables_internet_connectivity,
        )

        return typing.cast(None, jsii.invoke(self, "addRoute", [id, options]))

    @jsii.member(jsii_name="associateNetworkAcl")
    def associate_network_acl(self, id: builtins.str, network_acl: INetworkAcl) -> None:
        '''Associate a Network ACL with this subnet.

        :param id: -
        :param network_acl: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0d81feca462ace797ec97844cac189b9e3be40d625f8d6197163463755d73c02)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument network_acl", value=network_acl, expected_type=type_hints["network_acl"])
        return typing.cast(None, jsii.invoke(self, "associateNetworkAcl", [id, network_acl]))

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone the subnet is located in.'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="dependencyElements")
    def dependency_elements(self) -> typing.List[_constructs_77d1e7e8.IDependable]:
        '''Parts of this VPC subnet.'''
        return typing.cast(typing.List[_constructs_77d1e7e8.IDependable], jsii.get(self, "dependencyElements"))

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force internet connectivity established on the VPC.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "internetConnectivityEstablished"))

    @builtins.property
    @jsii.member(jsii_name="ipv4CidrBlock")
    def ipv4_cidr_block(self) -> builtins.str:
        '''The IPv4 CIDR block for this subnet.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "ipv4CidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="networkAcl")
    def network_acl(self) -> INetworkAcl:
        '''Network ACL associated with this Subnet.

        Upon creation, this is the default ACL which allows all traffic, except
        explicit DENY entries that you add.

        You can replace it with a custom ACL which denies all traffic except
        the explicit ALLOW entries that you add by creating a ``NetworkAcl``
        object and calling ``associateNetworkAcl()``.
        '''
        return typing.cast(INetworkAcl, jsii.get(self, "networkAcl"))

    @builtins.property
    @jsii.member(jsii_name="routeTable")
    def route_table(self) -> IRouteTable:
        '''The routeTableId attached to this subnet.'''
        return typing.cast(IRouteTable, jsii.get(self, "routeTable"))

    @builtins.property
    @jsii.member(jsii_name="subnetAvailabilityZone")
    def subnet_availability_zone(self) -> builtins.str:
        '''
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="subnetId")
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.'''
        return typing.cast(builtins.str, jsii.get(self, "subnetId"))

    @builtins.property
    @jsii.member(jsii_name="subnetIpv6CidrBlocks")
    def subnet_ipv6_cidr_blocks(self) -> typing.List[builtins.str]:
        '''
        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "subnetIpv6CidrBlocks"))

    @builtins.property
    @jsii.member(jsii_name="subnetNetworkAclAssociationId")
    def subnet_network_acl_association_id(self) -> builtins.str:
        '''
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetNetworkAclAssociationId"))

    @builtins.property
    @jsii.member(jsii_name="subnetOutpostArn")
    def subnet_outpost_arn(self) -> builtins.str:
        '''The Amazon Resource Name (ARN) of the Outpost for this subnet (if one exists).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetOutpostArn"))

    @builtins.property
    @jsii.member(jsii_name="subnetVpcId")
    def subnet_vpc_id(self) -> builtins.str:
        '''
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetVpcId"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "subnet_id": "subnetId",
        "availability_zone": "availabilityZone",
        "ipv4_cidr_block": "ipv4CidrBlock",
        "route_table_id": "routeTableId",
    },
)
class SubnetAttributes:
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints

        :exampleMetadata: infused

        Example::

            # Supply all properties
            subnet1 = ec2.Subnet.from_subnet_attributes(self, "SubnetFromAttributes",
                subnet_id="s-1234",
                availability_zone="pub-az-4465",
                route_table_id="rt-145"
            )
            
            # Supply only subnet id
            subnet2 = ec2.Subnet.from_subnet_id(self, "SubnetFromId", "s-1234")
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f05cd73c1131d6a52fa73b365bc4192bdab3617a60af5aabdd9f57e9c5f3d966)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument ipv4_cidr_block", value=ipv4_cidr_block, expected_type=type_hints["ipv4_cidr_block"])
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if ipv4_cidr_block is not None:
            self._values["ipv4_cidr_block"] = ipv4_cidr_block
        if route_table_id is not None:
            self._values["route_table_id"] = route_table_id

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.'''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone the subnet is located in.

        :default: - No AZ information, cannot use AZ selection features
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR block associated with the subnet.

        :default: - No CIDR information, cannot use CIDR filter features
        '''
        result = self._values.get("ipv4_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the route table for this particular subnet.

        :default: - No route table information, cannot create VPC endpoints
        '''
        result = self._values.get("route_table_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "name": "name",
        "subnet_type": "subnetType",
        "cidr_mask": "cidrMask",
        "ipv6_assign_address_on_creation": "ipv6AssignAddressOnCreation",
        "map_public_ip_on_launch": "mapPublicIpOnLaunch",
        "reserved": "reserved",
    },
)
class SubnetConfiguration:
    def __init__(
        self,
        *,
        name: builtins.str,
        subnet_type: "SubnetType",
        cidr_mask: typing.Optional[jsii.Number] = None,
        ipv6_assign_address_on_creation: typing.Optional[builtins.bool] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
        reserved: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Specify configuration parameters for a single subnet group in a VPC.

        :param name: Logical name for the subnet group. This name can be used when selecting VPC subnets to distinguish between different subnet groups of the same type.
        :param subnet_type: The type of Subnet to configure. The Subnet type will control the ability to route and connect to the Internet.
        :param cidr_mask: The number of leading 1 bits in the routing mask. The number of available IP addresses in each subnet of this group will be equal to ``2^(32 - cidrMask) - 2``. Valid values are ``16--28``. Note this is specific to IPv4 addresses. Default: - Available IP space is evenly divided across subnets.
        :param ipv6_assign_address_on_creation: This property is specific to dual stack VPCs. If set to false, then an IPv6 address will not be automatically assigned. Note this is specific to IPv6 addresses. Default: true
        :param map_public_ip_on_launch: Controls if a public IPv4 address is associated to an instance at launch. Note this is specific to IPv4 addresses. Default: true in Subnet.Public of IPV4_ONLY VPCs, false otherwise
        :param reserved: Controls if subnet IP space needs to be reserved. When true, the IP space for the subnet is reserved but no actual resources are provisioned. This space is only dependent on the number of availability zones and on ``cidrMask`` - all other subnet properties are ignored. Default: false

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            subnet_configuration = ec2.SubnetConfiguration(
                name="name",
                subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
            
                # the properties below are optional
                cidr_mask=123,
                ipv6_assign_address_on_creation=False,
                map_public_ip_on_launch=False,
                reserved=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__baa3ee59a393e7b31ebd9fb93534d193f13157ae242ba82fee91bdb0942fc507)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument subnet_type", value=subnet_type, expected_type=type_hints["subnet_type"])
            check_type(argname="argument cidr_mask", value=cidr_mask, expected_type=type_hints["cidr_mask"])
            check_type(argname="argument ipv6_assign_address_on_creation", value=ipv6_assign_address_on_creation, expected_type=type_hints["ipv6_assign_address_on_creation"])
            check_type(argname="argument map_public_ip_on_launch", value=map_public_ip_on_launch, expected_type=type_hints["map_public_ip_on_launch"])
            check_type(argname="argument reserved", value=reserved, expected_type=type_hints["reserved"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "name": name,
            "subnet_type": subnet_type,
        }
        if cidr_mask is not None:
            self._values["cidr_mask"] = cidr_mask
        if ipv6_assign_address_on_creation is not None:
            self._values["ipv6_assign_address_on_creation"] = ipv6_assign_address_on_creation
        if map_public_ip_on_launch is not None:
            self._values["map_public_ip_on_launch"] = map_public_ip_on_launch
        if reserved is not None:
            self._values["reserved"] = reserved

    @builtins.property
    def name(self) -> builtins.str:
        '''Logical name for the subnet group.

        This name can be used when selecting VPC subnets to distinguish
        between different subnet groups of the same type.
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def subnet_type(self) -> "SubnetType":
        '''The type of Subnet to configure.

        The Subnet type will control the ability to route and connect to the
        Internet.
        '''
        result = self._values.get("subnet_type")
        assert result is not None, "Required property 'subnet_type' is missing"
        return typing.cast("SubnetType", result)

    @builtins.property
    def cidr_mask(self) -> typing.Optional[jsii.Number]:
        '''The number of leading 1 bits in the routing mask.

        The number of available IP addresses in each subnet of this group
        will be equal to ``2^(32 - cidrMask) - 2``.

        Valid values are ``16--28``.

        Note this is specific to IPv4 addresses.

        :default: - Available IP space is evenly divided across subnets.
        '''
        result = self._values.get("cidr_mask")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def ipv6_assign_address_on_creation(self) -> typing.Optional[builtins.bool]:
        '''This property is specific to dual stack VPCs.

        If set to false, then an IPv6 address will not be automatically assigned.

        Note this is specific to IPv6 addresses.

        :default: true
        '''
        result = self._values.get("ipv6_assign_address_on_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def map_public_ip_on_launch(self) -> typing.Optional[builtins.bool]:
        '''Controls if a public IPv4 address is associated to an instance at launch.

        Note this is specific to IPv4 addresses.

        :default: true in Subnet.Public of IPV4_ONLY VPCs, false otherwise
        '''
        result = self._values.get("map_public_ip_on_launch")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def reserved(self) -> typing.Optional[builtins.bool]:
        '''Controls if subnet IP space needs to be reserved.

        When true, the IP space for the subnet is reserved but no actual
        resources are provisioned. This space is only dependent on the
        number of availability zones and on ``cidrMask`` - all other subnet
        properties are ignored.

        :default: false
        '''
        result = self._values.get("reserved")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class SubnetFilter(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.SubnetFilter",
):
    '''Contains logic which chooses a set of subnets from a larger list, in conjunction with SubnetSelection, to determine where to place AWS resources such as VPC endpoints, EC2 instances, etc.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        subnet_filter = ec2.SubnetFilter.availability_zones(["availabilityZones"])
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="availabilityZones")
    @builtins.classmethod
    def availability_zones(
        cls,
        availability_zones: typing.Sequence[builtins.str],
    ) -> "SubnetFilter":
        '''Chooses subnets which are in one of the given availability zones.

        :param availability_zones: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__38a0cc1a76167da2a235b0ca0b3ba3ca0a87e0efbda2debefac713e7a6c255ab)
            check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "availabilityZones", [availability_zones]))

    @jsii.member(jsii_name="byCidrMask")
    @builtins.classmethod
    def by_cidr_mask(cls, mask: jsii.Number) -> "SubnetFilter":
        '''Chooses subnets which have the provided CIDR netmask.

        :param mask: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__69817919d55fddaff58315445955b1b04b31a7f1747a977f7574982392cb8522)
            check_type(argname="argument mask", value=mask, expected_type=type_hints["mask"])
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "byCidrMask", [mask]))

    @jsii.member(jsii_name="byCidrRanges")
    @builtins.classmethod
    def by_cidr_ranges(cls, cidrs: typing.Sequence[builtins.str]) -> "SubnetFilter":
        '''Chooses subnets which are inside any of the specified CIDR range.

        :param cidrs: List of CIDR ranges to filter subnets from.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd66e1d5763d32bc4d66828de712617e6b80071fc6c692fb79248a7fcc0fc64e)
            check_type(argname="argument cidrs", value=cidrs, expected_type=type_hints["cidrs"])
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "byCidrRanges", [cidrs]))

    @jsii.member(jsii_name="byIds")
    @builtins.classmethod
    def by_ids(cls, subnet_ids: typing.Sequence[builtins.str]) -> "SubnetFilter":
        '''Chooses subnets by id.

        :param subnet_ids: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf740d57d9f14a6f82616f01d138bbcde7a61f1bcf4e42d9a86aa45df2b10e3f)
            check_type(argname="argument subnet_ids", value=subnet_ids, expected_type=type_hints["subnet_ids"])
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "byIds", [subnet_ids]))

    @jsii.member(jsii_name="containsIpAddresses")
    @builtins.classmethod
    def contains_ip_addresses(
        cls,
        ipv4addrs: typing.Sequence[builtins.str],
    ) -> "SubnetFilter":
        '''Chooses subnets which contain any of the specified IP addresses.

        :param ipv4addrs: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__030671c7b435b5214882053b1def40a66979057219ca4d8b8ddf624772d7835e)
            check_type(argname="argument ipv4addrs", value=ipv4addrs, expected_type=type_hints["ipv4addrs"])
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "containsIpAddresses", [ipv4addrs]))

    @jsii.member(jsii_name="onePerAz")
    @builtins.classmethod
    def one_per_az(cls) -> "SubnetFilter":
        '''Chooses subnets such that there is at most one per availability zone.'''
        return typing.cast("SubnetFilter", jsii.sinvoke(cls, "onePerAz", []))

    @jsii.member(jsii_name="selectSubnets")
    def select_subnets(
        self,
        _subnets: typing.Sequence[ISubnet],
    ) -> typing.List[ISubnet]:
        '''Executes the subnet filtering logic, returning a filtered set of subnets.

        :param _subnets: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0f87db5a7078178bd2ac961cf25c46aeea132e2b3aa4a72691a64058ac3a6a0a)
            check_type(argname="argument _subnets", value=_subnets, expected_type=type_hints["_subnets"])
        return typing.cast(typing.List[ISubnet], jsii.invoke(self, "selectSubnets", [_subnets]))


class _SubnetFilterProxy(SubnetFilter):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, SubnetFilter).__jsii_proxy_class__ = lambda : _SubnetFilterProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetIpamOptions",
    jsii_struct_bases=[],
    name_mapping={"allocated_subnets": "allocatedSubnets"},
)
class SubnetIpamOptions:
    def __init__(
        self,
        *,
        allocated_subnets: typing.Sequence[typing.Union[AllocatedSubnet, typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''CIDR Allocated Subnets.

        :param allocated_subnets: CIDR Allocations for Subnets.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            subnet_ipam_options = ec2.SubnetIpamOptions(
                allocated_subnets=[ec2.AllocatedSubnet(
                    cidr="cidr",
            
                    # the properties below are optional
                    ipv6_cidr="ipv6Cidr"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b35738458ba5f72eb4c1356a32b03d81940b1f9303a0725fa8ec4903241eb6a)
            check_type(argname="argument allocated_subnets", value=allocated_subnets, expected_type=type_hints["allocated_subnets"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "allocated_subnets": allocated_subnets,
        }

    @builtins.property
    def allocated_subnets(self) -> typing.List[AllocatedSubnet]:
        '''CIDR Allocations for Subnets.'''
        result = self._values.get("allocated_subnets")
        assert result is not None, "Required property 'allocated_subnets' is missing"
        return typing.cast(typing.List[AllocatedSubnet], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetIpamOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ISubnetNetworkAclAssociation)
class SubnetNetworkAclAssociation(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.SubnetNetworkAclAssociation",
):
    '''
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # network_acl: ec2.NetworkAcl
        # subnet: ec2.Subnet
        
        subnet_network_acl_association = ec2.SubnetNetworkAclAssociation(self, "MySubnetNetworkAclAssociation",
            network_acl=network_acl,
            subnet=subnet,
        
            # the properties below are optional
            subnet_network_acl_association_name="subnetNetworkAclAssociationName"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        network_acl: INetworkAcl,
        subnet: ISubnet,
        subnet_network_acl_association_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param network_acl: The Network ACL this association is defined for.
        :param subnet: ID of the Subnet.
        :param subnet_network_acl_association_name: The name of the SubnetNetworkAclAssociation. It is not recommended to use an explicit name. Default: If you don't specify a SubnetNetworkAclAssociationName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__338ce06855fa4f764a7a3f24d490fe607a06dc37057a15554cef0543f2542c5d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = SubnetNetworkAclAssociationProps(
            network_acl=network_acl,
            subnet=subnet,
            subnet_network_acl_association_name=subnet_network_acl_association_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromSubnetNetworkAclAssociationAssociationId")
    @builtins.classmethod
    def from_subnet_network_acl_association_association_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        subnet_network_acl_association_association_id: builtins.str,
    ) -> ISubnetNetworkAclAssociation:
        '''
        :param scope: -
        :param id: -
        :param subnet_network_acl_association_association_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9af4ad14510b112cde9defbcec82c0dde1def317501d84187a374149eb7699da)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument subnet_network_acl_association_association_id", value=subnet_network_acl_association_association_id, expected_type=type_hints["subnet_network_acl_association_association_id"])
        return typing.cast(ISubnetNetworkAclAssociation, jsii.sinvoke(cls, "fromSubnetNetworkAclAssociationAssociationId", [scope, id, subnet_network_acl_association_association_id]))

    @builtins.property
    @jsii.member(jsii_name="networkAcl")
    def network_acl(self) -> INetworkAcl:
        '''ID for the current Network ACL.

        :attribute: true
        '''
        return typing.cast(INetworkAcl, jsii.get(self, "networkAcl"))

    @builtins.property
    @jsii.member(jsii_name="subnet")
    def subnet(self) -> ISubnet:
        '''ID of the Subnet.

        :attribute: true
        '''
        return typing.cast(ISubnet, jsii.get(self, "subnet"))

    @builtins.property
    @jsii.member(jsii_name="subnetNetworkAclAssociationAssociationId")
    def subnet_network_acl_association_association_id(self) -> builtins.str:
        '''ID for the current SubnetNetworkAclAssociation.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "subnetNetworkAclAssociationAssociationId"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetNetworkAclAssociationProps",
    jsii_struct_bases=[],
    name_mapping={
        "network_acl": "networkAcl",
        "subnet": "subnet",
        "subnet_network_acl_association_name": "subnetNetworkAclAssociationName",
    },
)
class SubnetNetworkAclAssociationProps:
    def __init__(
        self,
        *,
        network_acl: INetworkAcl,
        subnet: ISubnet,
        subnet_network_acl_association_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties to create a SubnetNetworkAclAssociation.

        :param network_acl: The Network ACL this association is defined for.
        :param subnet: ID of the Subnet.
        :param subnet_network_acl_association_name: The name of the SubnetNetworkAclAssociation. It is not recommended to use an explicit name. Default: If you don't specify a SubnetNetworkAclAssociationName, AWS CloudFormation generates a unique physical ID and uses that ID for the group name.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # network_acl: ec2.NetworkAcl
            # subnet: ec2.Subnet
            
            subnet_network_acl_association_props = ec2.SubnetNetworkAclAssociationProps(
                network_acl=network_acl,
                subnet=subnet,
            
                # the properties below are optional
                subnet_network_acl_association_name="subnetNetworkAclAssociationName"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53d927301a63c79d241c9915400b7d48edcdb0f410ad38d20c44bc9e6cf5f0e9)
            check_type(argname="argument network_acl", value=network_acl, expected_type=type_hints["network_acl"])
            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
            check_type(argname="argument subnet_network_acl_association_name", value=subnet_network_acl_association_name, expected_type=type_hints["subnet_network_acl_association_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "network_acl": network_acl,
            "subnet": subnet,
        }
        if subnet_network_acl_association_name is not None:
            self._values["subnet_network_acl_association_name"] = subnet_network_acl_association_name

    @builtins.property
    def network_acl(self) -> INetworkAcl:
        '''The Network ACL this association is defined for.

        :attribute: true
        '''
        result = self._values.get("network_acl")
        assert result is not None, "Required property 'network_acl' is missing"
        return typing.cast(INetworkAcl, result)

    @builtins.property
    def subnet(self) -> ISubnet:
        '''ID of the Subnet.

        :attribute: true
        '''
        result = self._values.get("subnet")
        assert result is not None, "Required property 'subnet' is missing"
        return typing.cast(ISubnet, result)

    @builtins.property
    def subnet_network_acl_association_name(self) -> typing.Optional[builtins.str]:
        '''The name of the SubnetNetworkAclAssociation.

        It is not recommended to use an explicit name.

        :default:

        If you don't specify a SubnetNetworkAclAssociationName, AWS CloudFormation generates a
        unique physical ID and uses that ID for the group name.
        '''
        result = self._values.get("subnet_network_acl_association_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetNetworkAclAssociationProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "cidr_block": "cidrBlock",
        "vpc_id": "vpcId",
        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "map_public_ip_on_launch": "mapPublicIpOnLaunch",
    },
)
class SubnetProps:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Specify configuration parameters for a VPC subnet.

        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            subnet_props = ec2.SubnetProps(
                availability_zone="availabilityZone",
                cidr_block="cidrBlock",
                vpc_id="vpcId",
            
                # the properties below are optional
                assign_ipv6_address_on_creation=False,
                ipv6_cidr_block="ipv6CidrBlock",
                map_public_ip_on_launch=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__63f433ea25e21dd7ee82ea9baf14e6a2200b884cccc4bc9ff2d6e0f12ca82f54)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument assign_ipv6_address_on_creation", value=assign_ipv6_address_on_creation, expected_type=type_hints["assign_ipv6_address_on_creation"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument map_public_ip_on_launch", value=map_public_ip_on_launch, expected_type=type_hints["map_public_ip_on_launch"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "cidr_block": cidr_block,
            "vpc_id": vpc_id,
        }
        if assign_ipv6_address_on_creation is not None:
            self._values["assign_ipv6_address_on_creation"] = assign_ipv6_address_on_creation
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if map_public_ip_on_launch is not None:
            self._values["map_public_ip_on_launch"] = map_public_ip_on_launch

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The availability zone for the subnet.'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr_block(self) -> builtins.str:
        '''The CIDR notation for this subnet.'''
        result = self._values.get("cidr_block")
        assert result is not None, "Required property 'cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The VPC which this subnet is part of.'''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def assign_ipv6_address_on_creation(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether a network interface created in this subnet receives an IPv6 address.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: false
        '''
        result = self._values.get("assign_ipv6_address_on_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: - no IPv6 CIDR block.
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def map_public_ip_on_launch(self) -> typing.Optional[builtins.bool]:
        '''Controls if a public IP is associated to an instance at launch.

        :default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        result = self._values.get("map_public_ip_on_launch")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SubnetSelection",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zones": "availabilityZones",
        "one_per_az": "onePerAz",
        "subnet_filters": "subnetFilters",
        "subnet_group_name": "subnetGroupName",
        "subnets": "subnets",
        "subnet_type": "subnetType",
    },
)
class SubnetSelection:
    def __init__(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence[SubnetFilter]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional["SubnetType"] = None,
    ) -> None:
        '''Customize subnets that are selected for placement of ENIs.

        Constructs that allow customization of VPC placement use parameters of this
        type to provide placement settings.

        By default, the instances are placed in the private subnets.

        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            cluster = rds.DatabaseCluster(self, "Database",
                engine=rds.DatabaseClusterEngine.aurora_mysql(
                    version=rds.AuroraMysqlEngineVersion.VER_3_03_0
                ),
                instances=2,
                instance_props=rds.InstanceProps(
                    instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL),
                    vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
                    vpc=vpc
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b4d4eba0670903dc365107b85eb99d41b1f814f9c8eed60e7014fd64063539e4)
            check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
            check_type(argname="argument one_per_az", value=one_per_az, expected_type=type_hints["one_per_az"])
            check_type(argname="argument subnet_filters", value=subnet_filters, expected_type=type_hints["subnet_filters"])
            check_type(argname="argument subnet_group_name", value=subnet_group_name, expected_type=type_hints["subnet_group_name"])
            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
            check_type(argname="argument subnet_type", value=subnet_type, expected_type=type_hints["subnet_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if availability_zones is not None:
            self._values["availability_zones"] = availability_zones
        if one_per_az is not None:
            self._values["one_per_az"] = one_per_az
        if subnet_filters is not None:
            self._values["subnet_filters"] = subnet_filters
        if subnet_group_name is not None:
            self._values["subnet_group_name"] = subnet_group_name
        if subnets is not None:
            self._values["subnets"] = subnets
        if subnet_type is not None:
            self._values["subnet_type"] = subnet_type

    @builtins.property
    def availability_zones(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Select subnets only in the given AZs.

        :default: no filtering on AZs is done
        '''
        result = self._values.get("availability_zones")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def one_per_az(self) -> typing.Optional[builtins.bool]:
        '''If true, return at most one subnet per AZ.

        :default: false
        '''
        result = self._values.get("one_per_az")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subnet_filters(self) -> typing.Optional[typing.List[SubnetFilter]]:
        '''List of provided subnet filters.

        :default: - none
        '''
        result = self._values.get("subnet_filters")
        return typing.cast(typing.Optional[typing.List[SubnetFilter]], result)

    @builtins.property
    def subnet_group_name(self) -> typing.Optional[builtins.str]:
        '''Select the subnet group with the given name.

        Select the subnet group with the given name. This only needs
        to be used if you have multiple subnet groups of the same type
        and you need to distinguish between them. Otherwise, prefer
        ``subnetType``.

        This field does not select individual subnets, it selects all subnets that
        share the given subnet group name. This is the name supplied in
        ``subnetConfiguration``.

        At most one of ``subnetType`` and ``subnetGroupName`` can be supplied.

        :default: - Selection by type instead of by name
        '''
        result = self._values.get("subnet_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def subnets(self) -> typing.Optional[typing.List[ISubnet]]:
        '''Explicitly select individual subnets.

        Use this if you don't want to automatically use all subnets in
        a group, but have a need to control selection down to
        individual subnets.

        Cannot be specified together with ``subnetType`` or ``subnetGroupName``.

        :default: - Use all subnets in a selected group (all private subnets by default)
        '''
        result = self._values.get("subnets")
        return typing.cast(typing.Optional[typing.List[ISubnet]], result)

    @builtins.property
    def subnet_type(self) -> typing.Optional["SubnetType"]:
        '''Select all subnets of the given type.

        At most one of ``subnetType`` and ``subnetGroupName`` can be supplied.

        :default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        result = self._values.get("subnet_type")
        return typing.cast(typing.Optional["SubnetType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SubnetSelection(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.SubnetType")
class SubnetType(enum.Enum):
    '''The type of Subnet.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        cluster = rds.DatabaseCluster(self, "Database",
            engine=rds.DatabaseClusterEngine.aurora_mysql(
                version=rds.AuroraMysqlEngineVersion.VER_3_03_0
            ),
            instances=2,
            instance_props=rds.InstanceProps(
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.SMALL),
                vpc_subnets=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC),
                vpc=vpc
            )
        )
    '''

    PRIVATE_ISOLATED = "PRIVATE_ISOLATED"
    '''Isolated Subnets do not route traffic to the Internet (in this VPC), and as such, do not require NAT gateways.

    Isolated subnets can only connect to or be connected to from other
    instances in the same VPC. A default VPC configuration will not include
    isolated subnets.

    This can be good for subnets with RDS or Elasticache instances,
    or which route Internet traffic through a peer VPC.
    '''
    PRIVATE_WITH_EGRESS = "PRIVATE_WITH_EGRESS"
    '''Subnet that routes to the internet, but not vice versa.

    Instances in a private subnet can connect to the Internet, but will not
    allow connections to be initiated from the Internet. Egress to the internet will
    need to be provided.
    NAT Gateway(s) are the default solution to providing this subnet type the ability to route Internet traffic.
    If a NAT Gateway is not required or desired, set ``natGateways:0`` or use
    ``SubnetType.PRIVATE_ISOLATED`` instead.

    By default, a NAT gateway is created in every public subnet for maximum availability.
    Be aware that you will be charged for NAT gateways.

    Normally a Private subnet will use a NAT gateway in the same AZ, but
    if ``natGateways`` is used to reduce the number of NAT gateways, a NAT
    gateway from another AZ will be used instead.
    '''
    PRIVATE_WITH_NAT = "PRIVATE_WITH_NAT"
    '''(deprecated) Subnet that routes to the internet (via a NAT gateway), but not vice versa.

    Instances in a private subnet can connect to the Internet, but will not
    allow connections to be initiated from the Internet. NAT Gateway(s) are
    required with this subnet type to route the Internet traffic through.
    If a NAT Gateway is not required or desired, use ``SubnetType.PRIVATE_ISOLATED`` instead.

    By default, a NAT gateway is created in every public subnet for maximum availability.
    Be aware that you will be charged for NAT gateways.

    Normally a Private subnet will use a NAT gateway in the same AZ, but
    if ``natGateways`` is used to reduce the number of NAT gateways, a NAT
    gateway from another AZ will be used instead.

    :deprecated: use ``PRIVATE_WITH_EGRESS``

    :stability: deprecated
    '''
    PUBLIC = "PUBLIC"
    '''Subnet connected to the Internet.

    Instances in a Public subnet can connect to the Internet and can be
    connected to from the Internet as long as they are launched with public
    IPs (controlled on the AutoScalingGroup or other constructs that launch
    instances).

    Public subnets route outbound traffic via an Internet Gateway.
    '''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.SystemdConfigFileOptions",
    jsii_struct_bases=[],
    name_mapping={
        "command": "command",
        "after_network": "afterNetwork",
        "cwd": "cwd",
        "description": "description",
        "group": "group",
        "keep_running": "keepRunning",
        "user": "user",
    },
)
class SystemdConfigFileOptions:
    def __init__(
        self,
        *,
        command: builtins.str,
        after_network: typing.Optional[builtins.bool] = None,
        cwd: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        group: typing.Optional[builtins.str] = None,
        keep_running: typing.Optional[builtins.bool] = None,
        user: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Options for creating a SystemD configuration file.

        :param command: The command to run to start this service.
        :param after_network: Start the service after the networking part of the OS comes up. Default: true
        :param cwd: The working directory for the command. Default: Root directory or home directory of specified user
        :param description: A description of this service. Default: - No description
        :param group: The group to execute the process under. Default: root
        :param keep_running: Keep the process running all the time. Restarts the process when it exits for any reason other than the machine shutting down. Default: true
        :param user: The user to execute the process under. Default: root

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            # instance_type: ec2.InstanceType
            
            
            ec2.Instance(self, "Instance",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=ec2.MachineImage.latest_amazon_linux2023(),
            
                init=ec2.CloudFormationInit.from_elements(
                    # Create a simple config file that runs a Python web server
                    ec2.InitService.systemd_config_file("simpleserver",
                        command="/usr/bin/python3 -m http.server 8080",
                        cwd="/var/www/html"
                    ),
                    # Start the server using SystemD
                    ec2.InitService.enable("simpleserver",
                        service_manager=ec2.ServiceManager.SYSTEMD
                    ),
                    # Drop an example file to show the web server working
                    ec2.InitFile.from_string("/var/www/html/index.html", "Hello! It's working!"))
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32d66fb5148d20d001b12c0d2a13afa9f9d62d2ad84dc7e3eccb544d63832e13)
            check_type(argname="argument command", value=command, expected_type=type_hints["command"])
            check_type(argname="argument after_network", value=after_network, expected_type=type_hints["after_network"])
            check_type(argname="argument cwd", value=cwd, expected_type=type_hints["cwd"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument group", value=group, expected_type=type_hints["group"])
            check_type(argname="argument keep_running", value=keep_running, expected_type=type_hints["keep_running"])
            check_type(argname="argument user", value=user, expected_type=type_hints["user"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "command": command,
        }
        if after_network is not None:
            self._values["after_network"] = after_network
        if cwd is not None:
            self._values["cwd"] = cwd
        if description is not None:
            self._values["description"] = description
        if group is not None:
            self._values["group"] = group
        if keep_running is not None:
            self._values["keep_running"] = keep_running
        if user is not None:
            self._values["user"] = user

    @builtins.property
    def command(self) -> builtins.str:
        '''The command to run to start this service.'''
        result = self._values.get("command")
        assert result is not None, "Required property 'command' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def after_network(self) -> typing.Optional[builtins.bool]:
        '''Start the service after the networking part of the OS comes up.

        :default: true
        '''
        result = self._values.get("after_network")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def cwd(self) -> typing.Optional[builtins.str]:
        '''The working directory for the command.

        :default: Root directory or home directory of specified user
        '''
        result = self._values.get("cwd")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def description(self) -> typing.Optional[builtins.str]:
        '''A description of this service.

        :default: - No description
        '''
        result = self._values.get("description")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def group(self) -> typing.Optional[builtins.str]:
        '''The group to execute the process under.

        :default: root
        '''
        result = self._values.get("group")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def keep_running(self) -> typing.Optional[builtins.bool]:
        '''Keep the process running all the time.

        Restarts the process when it exits for any reason other
        than the machine shutting down.

        :default: true
        '''
        result = self._values.get("keep_running")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user(self) -> typing.Optional[builtins.str]:
        '''The user to execute the process under.

        :default: root
        '''
        result = self._values.get("user")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SystemdConfigFileOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.TrafficDirection")
class TrafficDirection(enum.Enum):
    '''Direction of traffic the AclEntry applies to.'''

    EGRESS = "EGRESS"
    '''Traffic leaving the subnet.'''
    INGRESS = "INGRESS"
    '''Traffic entering the subnet.'''


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.TransportProtocol")
class TransportProtocol(enum.Enum):
    '''Transport protocol for client VPN.'''

    TCP = "TCP"
    '''Transmission Control Protocol (TCP).'''
    UDP = "UDP"
    '''User Datagram Protocol (UDP).'''


class UserData(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.UserData",
):
    '''Instance User Data.

    :exampleMetadata: infused

    Example::

        multipart_user_data = ec2.MultipartUserData()
        commands_user_data = ec2.UserData.for_linux()
        multipart_user_data.add_user_data_part(commands_user_data, ec2.MultipartBody.SHELL_SCRIPT, True)
        
        # Adding commands to the multipartUserData adds them to commandsUserData, and vice-versa.
        multipart_user_data.add_commands("touch /root/multi.txt")
        commands_user_data.add_commands("touch /root/userdata.txt")
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="custom")
    @builtins.classmethod
    def custom(cls, content: builtins.str) -> "UserData":
        '''Create a userdata object with custom content.

        :param content: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f5b8e62e9ffc24cea334d4b5b44cfc335970311198fb6a107bf4c7586b1c5da)
            check_type(argname="argument content", value=content, expected_type=type_hints["content"])
        return typing.cast("UserData", jsii.sinvoke(cls, "custom", [content]))

    @jsii.member(jsii_name="forLinux")
    @builtins.classmethod
    def for_linux(cls, *, shebang: typing.Optional[builtins.str] = None) -> "UserData":
        '''Create a userdata object for Linux hosts.

        :param shebang: Shebang for the UserData script. Default: "#!/bin/bash"
        '''
        options = LinuxUserDataOptions(shebang=shebang)

        return typing.cast("UserData", jsii.sinvoke(cls, "forLinux", [options]))

    @jsii.member(jsii_name="forOperatingSystem")
    @builtins.classmethod
    def for_operating_system(cls, os: OperatingSystemType) -> "UserData":
        '''
        :param os: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2417045643900e8acec1701e4e4fe91a96c2b290138c6819b1f1003c232a615f)
            check_type(argname="argument os", value=os, expected_type=type_hints["os"])
        return typing.cast("UserData", jsii.sinvoke(cls, "forOperatingSystem", [os]))

    @jsii.member(jsii_name="forWindows")
    @builtins.classmethod
    def for_windows(
        cls,
        *,
        persist: typing.Optional[builtins.bool] = None,
    ) -> "UserData":
        '''Create a userdata object for Windows hosts.

        :param persist: Set to true to set this userdata to persist through an instance reboot; allowing it to run on every instance start. By default, UserData is run only once during the first instance launch. For more information, see: https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/ https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-windows-user-data.html#user-data-scripts Default: false
        '''
        options = WindowsUserDataOptions(persist=persist)

        return typing.cast("UserData", jsii.sinvoke(cls, "forWindows", [options]))

    @jsii.member(jsii_name="addCommands")
    @abc.abstractmethod
    def add_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data.

        :param commands: -
        '''
        ...

    @jsii.member(jsii_name="addExecuteFileCommand")
    @abc.abstractmethod
    def add_execute_file_command(
        self,
        *,
        file_path: builtins.str,
        arguments: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Adds commands to execute a file.

        :param file_path: The path to the file.
        :param arguments: The arguments to be passed to the file. Default: No arguments are passed to the file.
        '''
        ...

    @jsii.member(jsii_name="addOnExitCommands")
    @abc.abstractmethod
    def add_on_exit_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data that will run when the script exits.

        :param commands: -
        '''
        ...

    @jsii.member(jsii_name="addS3DownloadCommand")
    @abc.abstractmethod
    def add_s3_download_command(
        self,
        *,
        bucket: _IBucket_42e086fd,
        bucket_key: builtins.str,
        local_file: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''Adds commands to download a file from S3.

        :param bucket: Name of the S3 bucket to download from.
        :param bucket_key: The key of the file to download.
        :param local_file: The name of the local file. Default: Linux - /tmp/bucketKey Windows - %TEMP%/bucketKey
        :param region: The region of the S3 Bucket (needed for access via VPC Gateway). Default: none

        :return: : The local path that the file will be downloaded to
        '''
        ...

    @jsii.member(jsii_name="addSignalOnExitCommand")
    @abc.abstractmethod
    def add_signal_on_exit_command(self, resource: _Resource_45bc6135) -> None:
        '''Adds a command which will send a cfn-signal when the user data script ends.

        :param resource: -
        '''
        ...

    @jsii.member(jsii_name="render")
    @abc.abstractmethod
    def render(self) -> builtins.str:
        '''Render the UserData for use in a construct.'''
        ...


class _UserDataProxy(UserData):
    @jsii.member(jsii_name="addCommands")
    def add_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data.

        :param commands: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c54102a3fb4a84adf98707676e047132a6ae8036637677c2d31a8d6f2d11fd39)
            check_type(argname="argument commands", value=commands, expected_type=typing.Tuple[type_hints["commands"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addCommands", [*commands]))

    @jsii.member(jsii_name="addExecuteFileCommand")
    def add_execute_file_command(
        self,
        *,
        file_path: builtins.str,
        arguments: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Adds commands to execute a file.

        :param file_path: The path to the file.
        :param arguments: The arguments to be passed to the file. Default: No arguments are passed to the file.
        '''
        params = ExecuteFileOptions(file_path=file_path, arguments=arguments)

        return typing.cast(None, jsii.invoke(self, "addExecuteFileCommand", [params]))

    @jsii.member(jsii_name="addOnExitCommands")
    def add_on_exit_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data that will run when the script exits.

        :param commands: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__26e31dd2bd42518698d0d4e4ed3b64ee76fbf8301133acbad770f19dfa6ebb33)
            check_type(argname="argument commands", value=commands, expected_type=typing.Tuple[type_hints["commands"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addOnExitCommands", [*commands]))

    @jsii.member(jsii_name="addS3DownloadCommand")
    def add_s3_download_command(
        self,
        *,
        bucket: _IBucket_42e086fd,
        bucket_key: builtins.str,
        local_file: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''Adds commands to download a file from S3.

        :param bucket: Name of the S3 bucket to download from.
        :param bucket_key: The key of the file to download.
        :param local_file: The name of the local file. Default: Linux - /tmp/bucketKey Windows - %TEMP%/bucketKey
        :param region: The region of the S3 Bucket (needed for access via VPC Gateway). Default: none

        :return: : The local path that the file will be downloaded to
        '''
        params = S3DownloadOptions(
            bucket=bucket, bucket_key=bucket_key, local_file=local_file, region=region
        )

        return typing.cast(builtins.str, jsii.invoke(self, "addS3DownloadCommand", [params]))

    @jsii.member(jsii_name="addSignalOnExitCommand")
    def add_signal_on_exit_command(self, resource: _Resource_45bc6135) -> None:
        '''Adds a command which will send a cfn-signal when the user data script ends.

        :param resource: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d5d1ebe2042e32db54b52ff3c694973ef3f7d0311a257f727d35f9577b02e2fa)
            check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
        return typing.cast(None, jsii.invoke(self, "addSignalOnExitCommand", [resource]))

    @jsii.member(jsii_name="render")
    def render(self) -> builtins.str:
        '''Render the UserData for use in a construct.'''
        return typing.cast(builtins.str, jsii.invoke(self, "render", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, UserData).__jsii_proxy_class__ = lambda : _UserDataProxy


@jsii.implements(IVolume)
class Volume(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.Volume",
):
    '''Creates a new EBS Volume in AWS EC2.

    :exampleMetadata: infused

    Example::

        # instance: ec2.Instance
        # role: iam.Role
        
        
        volume = ec2.Volume(self, "Volume",
            availability_zone="us-west-2a",
            size=Size.gibibytes(500),
            encrypted=True
        )
        
        volume.grant_attach_volume(role, [instance])
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        auto_enable_io: typing.Optional[builtins.bool] = None,
        enable_multi_attach: typing.Optional[builtins.bool] = None,
        encrypted: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional[_IKey_5f11635f] = None,
        iops: typing.Optional[jsii.Number] = None,
        removal_policy: typing.Optional[_RemovalPolicy_9f93c814] = None,
        size: typing.Optional[_Size_7b441c34] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
        throughput: typing.Optional[jsii.Number] = None,
        volume_name: typing.Optional[builtins.str] = None,
        volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param availability_zone: The Availability Zone in which to create the volume.
        :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
        :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
        :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
        :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
        :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
        :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7e030ab114373c1029fa90c55af2097b08d29de0c6045a2812c36b009d38d3c6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = VolumeProps(
            availability_zone=availability_zone,
            auto_enable_io=auto_enable_io,
            enable_multi_attach=enable_multi_attach,
            encrypted=encrypted,
            encryption_key=encryption_key,
            iops=iops,
            removal_policy=removal_policy,
            size=size,
            snapshot_id=snapshot_id,
            throughput=throughput,
            volume_name=volume_name,
            volume_type=volume_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromVolumeAttributes")
    @builtins.classmethod
    def from_volume_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        volume_id: builtins.str,
        encryption_key: typing.Optional[_IKey_5f11635f] = None,
    ) -> IVolume:
        '''Import an existing EBS Volume into the Stack.

        :param scope: the scope of the import.
        :param id: the ID of the imported Volume in the construct tree.
        :param availability_zone: The availability zone that the EBS Volume is contained within (ex: us-west-2a).
        :param volume_id: The EBS Volume's ID.
        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. Default: None -- The EBS Volume is not using a customer-managed KMS key for encryption.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e30c09922d73a6f0b71dae72ddb6575e78d3e432fafa10ca51829be8df3b3800)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = VolumeAttributes(
            availability_zone=availability_zone,
            volume_id=volume_id,
            encryption_key=encryption_key,
        )

        return typing.cast(IVolume, jsii.sinvoke(cls, "fromVolumeAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="grantAttachVolume")
    def grant_attach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach this Volume to an instance.

        CAUTION: Granting an instance permission to attach to itself using this method will lead to
        an unresolvable circular reference between the instance role and the instance.
        Use ``IVolume.grantAttachVolumeToSelf`` to grant an instance permission to attach this
        volume to itself.

        :param grantee: -
        :param instances: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cdefa3ce29cd54855bbe41af0c55ecff6396ad9df29b998dfebc7ecba9eaac6)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument instances", value=instances, expected_type=type_hints["instances"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantAttachVolume", [grantee, instances]))

    @jsii.member(jsii_name="grantAttachVolumeByResourceTag")
    def grant_attach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to attach the Volume by a ResourceTag condition.

        If you are looking to
        grant an Instance, AutoScalingGroup, EC2-Fleet, SpotFleet, ECS host, etc the ability to attach
        this volume to **itself** then this is the method you want to use.

        This is implemented by adding a Tag with key ``VolumeGrantAttach-<suffix>`` to the given
        constructs and this Volume, and then conditioning the Grant such that the grantee is only
        given the ability to AttachVolume if both the Volume and the destination Instance have that
        tag applied to them.

        :param grantee: -
        :param constructs: -
        :param tag_key_suffix: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42ca4325f507fbda18080360712b4c2c10961faa37b2164974b01340c7cf0629)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument constructs", value=constructs, expected_type=type_hints["constructs"])
            check_type(argname="argument tag_key_suffix", value=tag_key_suffix, expected_type=type_hints["tag_key_suffix"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantAttachVolumeByResourceTag", [grantee, constructs, tag_key_suffix]))

    @jsii.member(jsii_name="grantDetachVolume")
    def grant_detach_volume(
        self,
        grantee: _IGrantable_71c4f5de,
        instances: typing.Optional[typing.Sequence[IInstance]] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach this Volume from an instance CAUTION: Granting an instance permission to detach from itself using this method will lead to an unresolvable circular reference between the instance role and the instance.

        Use ``IVolume.grantDetachVolumeFromSelf`` to grant an instance permission to detach this
        volume from itself.

        :param grantee: -
        :param instances: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d727ce06c5eb68be96cf7e88f7ed53367cc010a82a04a06f85d0d9028830f72)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument instances", value=instances, expected_type=type_hints["instances"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantDetachVolume", [grantee, instances]))

    @jsii.member(jsii_name="grantDetachVolumeByResourceTag")
    def grant_detach_volume_by_resource_tag(
        self,
        grantee: _IGrantable_71c4f5de,
        constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
        tag_key_suffix: typing.Optional[builtins.str] = None,
    ) -> _Grant_a7ae64f8:
        '''Grants permission to detach the Volume by a ResourceTag condition.

        This is implemented via the same mechanism as ``IVolume.grantAttachVolumeByResourceTag``,
        and is subject to the same conditions.

        :param grantee: -
        :param constructs: -
        :param tag_key_suffix: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__488166c096839f9076f1efd3133211f3f69a0bac294256f886415b809357f412)
            check_type(argname="argument grantee", value=grantee, expected_type=type_hints["grantee"])
            check_type(argname="argument constructs", value=constructs, expected_type=type_hints["constructs"])
            check_type(argname="argument tag_key_suffix", value=tag_key_suffix, expected_type=type_hints["tag_key_suffix"])
        return typing.cast(_Grant_a7ae64f8, jsii.invoke(self, "grantDetachVolumeByResourceTag", [grantee, constructs, tag_key_suffix]))

    @jsii.member(jsii_name="validateProps")
    def _validate_props(
        self,
        *,
        availability_zone: builtins.str,
        auto_enable_io: typing.Optional[builtins.bool] = None,
        enable_multi_attach: typing.Optional[builtins.bool] = None,
        encrypted: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional[_IKey_5f11635f] = None,
        iops: typing.Optional[jsii.Number] = None,
        removal_policy: typing.Optional[_RemovalPolicy_9f93c814] = None,
        size: typing.Optional[_Size_7b441c34] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
        throughput: typing.Optional[jsii.Number] = None,
        volume_name: typing.Optional[builtins.str] = None,
        volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    ) -> None:
        '''
        :param availability_zone: The Availability Zone in which to create the volume.
        :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
        :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
        :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
        :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
        :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
        :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
        '''
        props = VolumeProps(
            availability_zone=availability_zone,
            auto_enable_io=auto_enable_io,
            enable_multi_attach=enable_multi_attach,
            encrypted=encrypted,
            encryption_key=encryption_key,
            iops=iops,
            removal_policy=removal_policy,
            size=size,
            snapshot_id=snapshot_id,
            throughput=throughput,
            volume_name=volume_name,
            volume_type=volume_type,
        )

        return typing.cast(None, jsii.invoke(self, "validateProps", [props]))

    @builtins.property
    @jsii.member(jsii_name="availabilityZone")
    def availability_zone(self) -> builtins.str:
        '''The availability zone that the EBS Volume is contained within (ex: us-west-2a).'''
        return typing.cast(builtins.str, jsii.get(self, "availabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="volumeId")
    def volume_id(self) -> builtins.str:
        '''The EBS Volume's ID.'''
        return typing.cast(builtins.str, jsii.get(self, "volumeId"))

    @builtins.property
    @jsii.member(jsii_name="encryptionKey")
    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The customer-managed encryption key that is used to encrypt the Volume.'''
        return typing.cast(typing.Optional[_IKey_5f11635f], jsii.get(self, "encryptionKey"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VolumeAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "volume_id": "volumeId",
        "encryption_key": "encryptionKey",
    },
)
class VolumeAttributes:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        volume_id: builtins.str,
        encryption_key: typing.Optional[_IKey_5f11635f] = None,
    ) -> None:
        '''Attributes required to import an existing EBS Volume into the Stack.

        :param availability_zone: The availability zone that the EBS Volume is contained within (ex: us-west-2a).
        :param volume_id: The EBS Volume's ID.
        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. Default: None -- The EBS Volume is not using a customer-managed KMS key for encryption.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_kms as kms
            
            # key: kms.Key
            
            volume_attributes = ec2.VolumeAttributes(
                availability_zone="availabilityZone",
                volume_id="volumeId",
            
                # the properties below are optional
                encryption_key=key
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eee031d929eff737032bb095bb111f3548f3b17ca6e438e9f4791022acd13407)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument volume_id", value=volume_id, expected_type=type_hints["volume_id"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "volume_id": volume_id,
        }
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The availability zone that the EBS Volume is contained within (ex: us-west-2a).'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def volume_id(self) -> builtins.str:
        '''The EBS Volume's ID.'''
        result = self._values.get("volume_id")
        assert result is not None, "Required property 'volume_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The customer-managed encryption key that is used to encrypt the Volume.

        :default: None -- The EBS Volume is not using a customer-managed KMS key for encryption.
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[_IKey_5f11635f], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VolumeAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VolumeProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zone": "availabilityZone",
        "auto_enable_io": "autoEnableIo",
        "enable_multi_attach": "enableMultiAttach",
        "encrypted": "encrypted",
        "encryption_key": "encryptionKey",
        "iops": "iops",
        "removal_policy": "removalPolicy",
        "size": "size",
        "snapshot_id": "snapshotId",
        "throughput": "throughput",
        "volume_name": "volumeName",
        "volume_type": "volumeType",
    },
)
class VolumeProps:
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        auto_enable_io: typing.Optional[builtins.bool] = None,
        enable_multi_attach: typing.Optional[builtins.bool] = None,
        encrypted: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional[_IKey_5f11635f] = None,
        iops: typing.Optional[jsii.Number] = None,
        removal_policy: typing.Optional[_RemovalPolicy_9f93c814] = None,
        size: typing.Optional[_Size_7b441c34] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
        throughput: typing.Optional[jsii.Number] = None,
        volume_name: typing.Optional[builtins.str] = None,
        volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    ) -> None:
        '''Properties of an EBS Volume.

        :param availability_zone: The Availability Zone in which to create the volume.
        :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
        :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
        :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
        :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
        :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
        :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``

        :exampleMetadata: infused

        Example::

            # instance: ec2.Instance
            # role: iam.Role
            
            
            volume = ec2.Volume(self, "Volume",
                availability_zone="us-west-2a",
                size=Size.gibibytes(500),
                encrypted=True
            )
            
            volume.grant_attach_volume(role, [instance])
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd11037db838f64c74264a09154568b99584932152ae7679e47051119dcaf1ed)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument auto_enable_io", value=auto_enable_io, expected_type=type_hints["auto_enable_io"])
            check_type(argname="argument enable_multi_attach", value=enable_multi_attach, expected_type=type_hints["enable_multi_attach"])
            check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument size", value=size, expected_type=type_hints["size"])
            check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
            check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
            check_type(argname="argument volume_name", value=volume_name, expected_type=type_hints["volume_name"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
        }
        if auto_enable_io is not None:
            self._values["auto_enable_io"] = auto_enable_io
        if enable_multi_attach is not None:
            self._values["enable_multi_attach"] = enable_multi_attach
        if encrypted is not None:
            self._values["encrypted"] = encrypted
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if iops is not None:
            self._values["iops"] = iops
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if size is not None:
            self._values["size"] = size
        if snapshot_id is not None:
            self._values["snapshot_id"] = snapshot_id
        if throughput is not None:
            self._values["throughput"] = throughput
        if volume_name is not None:
            self._values["volume_name"] = volume_name
        if volume_type is not None:
            self._values["volume_type"] = volume_type

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The Availability Zone in which to create the volume.'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def auto_enable_io(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether the volume is auto-enabled for I/O operations.

        By default, Amazon EBS disables I/O to the volume from attached EC2
        instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and
        you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.

        :default: false
        '''
        result = self._values.get("auto_enable_io")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def enable_multi_attach(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether Amazon EBS Multi-Attach is enabled.

        See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_
        for the constraints of multi-attach.

        :default: false
        '''
        result = self._values.get("enable_multi_attach")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encrypted(self) -> typing.Optional[builtins.bool]:
        '''Specifies whether the volume should be encrypted.

        The effect of setting the encryption state to true depends on the volume origin
        (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information,
        see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_
        in the Amazon Elastic Compute Cloud User Guide.

        Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see
        `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_.

        :default: false
        '''
        result = self._values.get("encrypted")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The customer-managed encryption key that is used to encrypt the Volume.

        The encrypted property must
        be true if this is provided.

        Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here,
        then the KMS key **must** have the following in its Key policy; otherwise, the Volume
        will fail to create::

           {
             "Effect": "Allow",
             "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" },
             "Resource": "*",
             "Action": [
               "kms:DescribeKey",
               "kms:GenerateDataKeyWithoutPlainText",
             ],
             "Condition": {
               "StringEquals": {
                 "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com)
                 "kms:CallerAccount": "0000000000" (your account ID)
               }
             }
           }

        :default: The default KMS key for the account, region, and EC2 service is used.
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional[_IKey_5f11635f], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS) to provision for the volume.

        The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD,
        and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3.
        See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
        for more information.

        This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes.

        :default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional[_RemovalPolicy_9f93c814]:
        '''Policy to apply when the volume is removed from the stack.

        :default: RemovalPolicy.RETAIN
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional[_RemovalPolicy_9f93c814], result)

    @builtins.property
    def size(self) -> typing.Optional[_Size_7b441c34]:
        '''The size of the volume, in GiBs.

        You must specify either a snapshot ID or a volume size.
        See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
        for details on the allowable size for each type of volume.

        :default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
        '''
        result = self._values.get("size")
        return typing.cast(typing.Optional[_Size_7b441c34], result)

    @builtins.property
    def snapshot_id(self) -> typing.Optional[builtins.str]:
        '''The snapshot from which to create the volume.

        You must specify either a snapshot ID or a volume size.

        :default: The EBS volume is not created from a snapshot.
        '''
        result = self._values.get("snapshot_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def throughput(self) -> typing.Optional[jsii.Number]:
        '''The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000.

        :default: - 125 MiB/s. Only valid on gp3 volumes.

        :see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-throughput
        '''
        result = self._values.get("throughput")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_name(self) -> typing.Optional[builtins.str]:
        '''The value of the physicalName property of this resource.

        :default: The physical name will be allocated by CloudFormation at deployment time
        '''
        result = self._values.get("volume_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def volume_type(self) -> typing.Optional[EbsDeviceVolumeType]:
        '''The type of the volume;

        what type of storage to use to form the EBS Volume.

        :default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional[EbsDeviceVolumeType], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VolumeProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IVpc)
class Vpc(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.Vpc",
):
    '''Define an AWS Virtual Private Cloud.

    See the package-level documentation of this package for an overview
    of the various dimensions in which you can configure your VPC.

    For example::

       vpc = ec2.Vpc(self, "TheVPC",
           ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/16")
       )

       # Iterate the private subnets
       selection = vpc.select_subnets(
           subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
       )

       for subnet in selection.subnets:
           pass

    :resource: AWS::EC2::VPC
    :exampleMetadata: infused

    Example::

        import aws_cdk.aws_ec2 as ec2
        
        
        vpc = ec2.Vpc(self, "Vpc",
            ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/16")
        )
        
        vpc_connector = apprunner.VpcConnector(self, "VpcConnector",
            vpc=vpc,
            vpc_subnets=vpc.select_subnets(subnet_type=ec2.SubnetType.PUBLIC),
            vpc_connector_name="MyVpcConnector"
        )
        
        apprunner.Service(self, "Service",
            source=apprunner.Source.from_ecr_public(
                image_configuration=apprunner.ImageConfiguration(port=8000),
                image_identifier="public.ecr.aws/aws-containers/hello-app-runner:latest"
            ),
            vpc_connector=vpc_connector
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        cidr: typing.Optional[builtins.str] = None,
        create_internet_gateway: typing.Optional[builtins.bool] = None,
        default_instance_tenancy: typing.Optional[DefaultInstanceTenancy] = None,
        enable_dns_hostnames: typing.Optional[builtins.bool] = None,
        enable_dns_support: typing.Optional[builtins.bool] = None,
        flow_logs: typing.Optional[typing.Mapping[builtins.str, typing.Union[FlowLogOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
        gateway_endpoints: typing.Optional[typing.Mapping[builtins.str, typing.Union[GatewayVpcEndpointOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
        ip_addresses: typing.Optional[IIpAddresses] = None,
        ip_protocol: typing.Optional[IpProtocol] = None,
        ipv6_addresses: typing.Optional[IIpv6Addresses] = None,
        max_azs: typing.Optional[jsii.Number] = None,
        nat_gateway_provider: typing.Optional[NatProvider] = None,
        nat_gateways: typing.Optional[jsii.Number] = None,
        nat_gateway_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
        reserved_azs: typing.Optional[jsii.Number] = None,
        restrict_default_security_group: typing.Optional[builtins.bool] = None,
        subnet_configuration: typing.Optional[typing.Sequence[typing.Union[SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_name: typing.Optional[builtins.str] = None,
        vpn_connections: typing.Optional[typing.Mapping[builtins.str, typing.Union["VpnConnectionOptions", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpn_gateway: typing.Optional[builtins.bool] = None,
        vpn_gateway_asn: typing.Optional[jsii.Number] = None,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Vpc creates a VPC that spans a whole region.

        It will automatically divide the provided VPC CIDR range, and create public and private subnets per Availability Zone.
        Network routing for the public subnets will be configured to allow outbound access directly via an Internet Gateway.
        Network routing for the private subnets will be configured to allow outbound access via a set of resilient NAT Gateways (one per AZ).

        :param scope: -
        :param id: -
        :param availability_zones: Availability zones this VPC spans. Specify this option only if you do not specify ``maxAzs``. Default: - a subset of AZs of the stack
        :param cidr: (deprecated) The CIDR range to use for the VPC, e.g. '10.0.0.0/16'. Should be a minimum of /28 and maximum size of /16. The range will be split across all subnets per Availability Zone. Default: Vpc.DEFAULT_CIDR_RANGE
        :param create_internet_gateway: If set to false then disable the creation of the default internet gateway. Default: true
        :param default_instance_tenancy: The default tenancy of instances launched into the VPC. By setting this to dedicated tenancy, instances will be launched on hardware dedicated to a single AWS customer, unless specifically specified at instance launch time. Please note, not all instance types are usable with Dedicated tenancy. Default: DefaultInstanceTenancy.Default (shared) tenancy
        :param enable_dns_hostnames: Indicates whether the instances launched in the VPC get public DNS hostnames. If this attribute is true, instances in the VPC get public DNS hostnames, but only if the enableDnsSupport attribute is also set to true. Default: true
        :param enable_dns_support: Indicates whether the DNS resolution is supported for the VPC. If this attribute is false, the Amazon-provided DNS server in the VPC that resolves public DNS hostnames to IP addresses is not enabled. If this attribute is true, queries to the Amazon provided DNS server at the 169.254.169.253 IP address, or the reserved IP address at the base of the VPC IPv4 network range plus two will succeed. Default: true
        :param flow_logs: Flow logs to add to this VPC. Default: - No flow logs.
        :param gateway_endpoints: Gateway endpoints to add to this VPC. Default: - None.
        :param ip_addresses: The Provider to use to allocate IPv4 Space to your VPC. Options include static allocation or from a pool. Note this is specific to IPv4 addresses. Default: ec2.IpAddresses.cidr
        :param ip_protocol: The protocol of the vpc. Options are IPv4 only or dual stack. Default: IpProtocol.IPV4_ONLY
        :param ipv6_addresses: The Provider to use to allocate IPv6 Space to your VPC. Options include amazon provided CIDR block. Note this is specific to IPv6 addresses. Default: Ipv6Addresses.amazonProvided
        :param max_azs: Define the maximum number of AZs to use in this region. If the region has more AZs than you want to use (for example, because of EIP limits), pick a lower number here. The AZs will be sorted and picked from the start of the list. If you pick a higher number than the number of AZs in the region, all AZs in the region will be selected. To use "all AZs" available to your account, use a high number (such as 99). Be aware that environment-agnostic stacks will be created with access to only 2 AZs, so to use more than 2 AZs, be sure to specify the account and region on your stack. Specify this option only if you do not specify ``availabilityZones``. Default: 3
        :param nat_gateway_provider: What type of NAT provider to use. Select between NAT gateways or NAT instances. NAT gateways may not be available in all AWS regions. Default: NatProvider.gateway()
        :param nat_gateways: The number of NAT Gateways/Instances to create. The type of NAT gateway or instance will be determined by the ``natGatewayProvider`` parameter. You can set this number lower than the number of Availability Zones in your VPC in order to save on NAT cost. Be aware you may be charged for cross-AZ data traffic instead. Default: - One NAT gateway/instance per Availability Zone
        :param nat_gateway_subnets: Configures the subnets which will have NAT Gateways/Instances. You can pick a specific group of subnets by specifying the group name; the picked subnets must be public subnets. Only necessary if you have more than one public subnet group. Default: - All public subnets.
        :param reserved_azs: Define the number of AZs to reserve. When specified, the IP space is reserved for the azs but no actual resources are provisioned. Default: 0
        :param restrict_default_security_group: If set to true then the default inbound & outbound rules will be removed from the default security group. Default: true if '@aws-cdk/aws-ec2:restrictDefaultSecurityGroup' is enabled, false otherwise
        :param subnet_configuration: Configure the subnets to build for each AZ. Each entry in this list configures a Subnet Group; each group will contain a subnet for each Availability Zone. For example, if you want 1 public subnet, 1 private subnet, and 1 isolated subnet in each AZ provide the following:: new ec2.Vpc(this, 'VPC', { subnetConfiguration: [ { cidrMask: 24, name: 'ingress', subnetType: ec2.SubnetType.PUBLIC, }, { cidrMask: 24, name: 'application', subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS, }, { cidrMask: 28, name: 'rds', subnetType: ec2.SubnetType.PRIVATE_ISOLATED, } ] }); Default: - The VPC CIDR will be evenly divided between 1 public and 1 private subnet per AZ.
        :param vpc_name: The VPC name. Since the VPC resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag Default: this.node.path
        :param vpn_connections: VPN connections to this VPC. Default: - No connections.
        :param vpn_gateway: Indicates whether a VPN gateway should be created and attached to this VPC. Default: - true when vpnGatewayAsn or vpnConnections is specified
        :param vpn_gateway_asn: The private Autonomous System Number (ASN) for the VPN gateway. Default: - Amazon default ASN.
        :param vpn_route_propagation: Where to propagate VPN routes. Default: - On the route tables associated with private subnets. If no private subnets exists, isolated subnets are used. If no isolated subnets exists, public subnets are used.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d4deef82a859d384a072185a8f3c2f8aec1cdbf45accc66513a1568835816af)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = VpcProps(
            availability_zones=availability_zones,
            cidr=cidr,
            create_internet_gateway=create_internet_gateway,
            default_instance_tenancy=default_instance_tenancy,
            enable_dns_hostnames=enable_dns_hostnames,
            enable_dns_support=enable_dns_support,
            flow_logs=flow_logs,
            gateway_endpoints=gateway_endpoints,
            ip_addresses=ip_addresses,
            ip_protocol=ip_protocol,
            ipv6_addresses=ipv6_addresses,
            max_azs=max_azs,
            nat_gateway_provider=nat_gateway_provider,
            nat_gateways=nat_gateways,
            nat_gateway_subnets=nat_gateway_subnets,
            reserved_azs=reserved_azs,
            restrict_default_security_group=restrict_default_security_group,
            subnet_configuration=subnet_configuration,
            vpc_name=vpc_name,
            vpn_connections=vpn_connections,
            vpn_gateway=vpn_gateway,
            vpn_gateway_asn=vpn_gateway_asn,
            vpn_route_propagation=vpn_route_propagation,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromLookup")
    @builtins.classmethod
    def from_lookup(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        is_default: typing.Optional[builtins.bool] = None,
        owner_account_id: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        return_vpn_gateways: typing.Optional[builtins.bool] = None,
        subnet_group_name_tag: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        vpc_id: typing.Optional[builtins.str] = None,
        vpc_name: typing.Optional[builtins.str] = None,
    ) -> IVpc:
        '''Import an existing VPC by querying the AWS environment this stack is deployed to.

        This function only needs to be used to use VPCs not defined in your CDK
        application. If you are looking to share a VPC between stacks, you can
        pass the ``Vpc`` object between stacks and use it as normal.

        Calling this method will lead to a lookup when the CDK CLI is executed.
        You can therefore not use any values that will only be available at
        CloudFormation execution time (i.e., Tokens).

        The VPC information will be cached in ``cdk.context.json`` and the same VPC
        will be used on future runs. To refresh the lookup, you will have to
        evict the value from the cache using the ``cdk context`` command. See
        https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.

        :param scope: -
        :param id: -
        :param is_default: Whether to match the default VPC. Default: Don't care whether we return the default VPC
        :param owner_account_id: The ID of the AWS account that owns the VPC. Default: the account id of the parent stack
        :param region: Optional to override inferred region. Default: Current stack's environment region
        :param return_vpn_gateways: Whether to look up whether a VPN Gateway is attached to the looked up VPC. You can set this to ``false`` if you know the VPC does not have a VPN Gateway attached, in order to avoid an API call. If you change this property from ``false`` to ``true`` or undefined, you may need to clear the corresponding context entry in ``cdk.context.json`` in order to trigger a new lookup. Default: true
        :param subnet_group_name_tag: Optional tag for subnet group name. If not provided, we'll look at the aws-cdk:subnet-name tag. If the subnet does not have the specified tag, we'll use its type as the name. Default: aws-cdk:subnet-name
        :param tags: Tags on the VPC. The VPC must have all of these tags Default: Don't filter on tags
        :param vpc_id: The ID of the VPC. If given, will import exactly this VPC. Default: Don't filter on vpcId
        :param vpc_name: The name of the VPC. If given, will import the VPC with this name. Default: Don't filter on vpcName
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__985d1aec6a93939347e8e9660018edf018502aaaf73913e84b68821667bd7071)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = VpcLookupOptions(
            is_default=is_default,
            owner_account_id=owner_account_id,
            region=region,
            return_vpn_gateways=return_vpn_gateways,
            subnet_group_name_tag=subnet_group_name_tag,
            tags=tags,
            vpc_id=vpc_id,
            vpc_name=vpc_name,
        )

        return typing.cast(IVpc, jsii.sinvoke(cls, "fromLookup", [scope, id, options]))

    @jsii.member(jsii_name="fromVpcAttributes")
    @builtins.classmethod
    def from_vpc_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zones: typing.Sequence[builtins.str],
        vpc_id: builtins.str,
        isolated_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        region: typing.Optional[builtins.str] = None,
        vpc_cidr_block: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
    ) -> IVpc:
        '''Import a VPC by supplying all attributes directly.

        NOTE: using ``fromVpcAttributes()`` with deploy-time parameters (like a ``Fn.importValue()`` or
        ``CfnParameter`` to represent a list of subnet IDs) sometimes accidentally works. It happens
        to work for constructs that need a list of subnets (like ``AutoScalingGroup`` and ``eks.Cluster``)
        but it does not work for constructs that need individual subnets (like
        ``Instance``). See https://github.com/aws/aws-cdk/issues/4118 for more
        information.

        Prefer to use ``Vpc.fromLookup()`` instead.

        :param scope: -
        :param id: -
        :param availability_zones: List of availability zones for the subnets in this VPC.
        :param vpc_id: VPC's identifier.
        :param isolated_subnet_ids: List of isolated subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any isolated subnets
        :param isolated_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the isolated subnets. Must be undefined or have an entry for every isolated subnet group. Default: - Retrieving the IPv4 CIDR block of any isolated subnet will fail
        :param isolated_subnet_names: List of names for the isolated subnets. Must be undefined or have a name for every isolated subnet group. Default: - All isolated subnets will have the name ``Isolated``
        :param isolated_subnet_route_table_ids: List of IDs of route tables for the isolated subnets. Must be undefined or have a name for every isolated subnet group. Default: - Retrieving the route table ID of any isolated subnet will fail
        :param private_subnet_ids: List of private subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any private subnets
        :param private_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the private subnets. Must be undefined or have an entry for every private subnet group. Default: - Retrieving the IPv4 CIDR block of any private subnet will fail
        :param private_subnet_names: List of names for the private subnets. Must be undefined or have a name for every private subnet group. Default: - All private subnets will have the name ``Private``
        :param private_subnet_route_table_ids: List of IDs of route tables for the private subnets. Must be undefined or have a name for every private subnet group. Default: - Retrieving the route table ID of any private subnet will fail
        :param public_subnet_ids: List of public subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any public subnets
        :param public_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the public subnets. Must be undefined or have an entry for every public subnet group. Default: - Retrieving the IPv4 CIDR block of any public subnet will fail
        :param public_subnet_names: List of names for the public subnets. Must be undefined or have a name for every public subnet group. Default: - All public subnets will have the name ``Public``
        :param public_subnet_route_table_ids: List of IDs of route tables for the public subnets. Must be undefined or have a name for every public subnet group. Default: - Retrieving the route table ID of any public subnet will fail
        :param region: The region the VPC is in. Default: - The region of the stack where the VPC belongs to
        :param vpc_cidr_block: VPC's CIDR range. Default: - Retrieving the CIDR from the VPC will fail
        :param vpn_gateway_id: VPN gateway's identifier.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__320b2b7a3ac9d81bbf6917f06aac2a5c2a0d2f83344960158393d5e34d748d41)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = VpcAttributes(
            availability_zones=availability_zones,
            vpc_id=vpc_id,
            isolated_subnet_ids=isolated_subnet_ids,
            isolated_subnet_ipv4_cidr_blocks=isolated_subnet_ipv4_cidr_blocks,
            isolated_subnet_names=isolated_subnet_names,
            isolated_subnet_route_table_ids=isolated_subnet_route_table_ids,
            private_subnet_ids=private_subnet_ids,
            private_subnet_ipv4_cidr_blocks=private_subnet_ipv4_cidr_blocks,
            private_subnet_names=private_subnet_names,
            private_subnet_route_table_ids=private_subnet_route_table_ids,
            public_subnet_ids=public_subnet_ids,
            public_subnet_ipv4_cidr_blocks=public_subnet_ipv4_cidr_blocks,
            public_subnet_names=public_subnet_names,
            public_subnet_route_table_ids=public_subnet_route_table_ids,
            region=region,
            vpc_cidr_block=vpc_cidr_block,
            vpn_gateway_id=vpn_gateway_id,
        )

        return typing.cast(IVpc, jsii.sinvoke(cls, "fromVpcAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="addClientVpnEndpoint")
    def add_client_vpn_endpoint(
        self,
        id: builtins.str,
        *,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional["VpnPort"] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional[TransportProtocol] = None,
        user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
        vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "ClientVpnEndpoint":
        '''Adds a new client VPN endpoint to this VPC.

        :param id: -
        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__04f8b7e933af74b695401b45c9c6b308e4684ecde3cb9a2a1e358a336c8f2195)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = ClientVpnEndpointOptions(
            cidr=cidr,
            server_certificate_arn=server_certificate_arn,
            authorize_all_users_to_vpc_cidr=authorize_all_users_to_vpc_cidr,
            client_certificate_arn=client_certificate_arn,
            client_connection_handler=client_connection_handler,
            client_login_banner=client_login_banner,
            description=description,
            dns_servers=dns_servers,
            logging=logging,
            log_group=log_group,
            log_stream=log_stream,
            port=port,
            security_groups=security_groups,
            self_service_portal=self_service_portal,
            session_timeout=session_timeout,
            split_tunnel=split_tunnel,
            transport_protocol=transport_protocol,
            user_based_authentication=user_based_authentication,
            vpc_subnets=vpc_subnets,
        )

        return typing.cast("ClientVpnEndpoint", jsii.invoke(self, "addClientVpnEndpoint", [id, options]))

    @jsii.member(jsii_name="addFlowLog")
    def add_flow_log(
        self,
        id: builtins.str,
        *,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional[FlowLogTrafficType] = None,
    ) -> "FlowLog":
        '''Adds a new flow log to this VPC.

        :param id: -
        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd705a6fb6eb81dd64ef1fed7a7ff93fff3a4c3c90d6479f35c18eca70fb9d0b)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = FlowLogOptions(
            destination=destination,
            log_format=log_format,
            max_aggregation_interval=max_aggregation_interval,
            traffic_type=traffic_type,
        )

        return typing.cast("FlowLog", jsii.invoke(self, "addFlowLog", [id, options]))

    @jsii.member(jsii_name="addGatewayEndpoint")
    def add_gateway_endpoint(
        self,
        id: builtins.str,
        *,
        service: IGatewayVpcEndpointService,
        subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "GatewayVpcEndpoint":
        '''Adds a new gateway endpoint to this VPC.

        :param id: -
        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79b57350b260f1ab40e4558402bb9540617b07ec5579d6e503c6d3d0ecad9b09)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = GatewayVpcEndpointOptions(service=service, subnets=subnets)

        return typing.cast("GatewayVpcEndpoint", jsii.invoke(self, "addGatewayEndpoint", [id, options]))

    @jsii.member(jsii_name="addInterfaceEndpoint")
    def add_interface_endpoint(
        self,
        id: builtins.str,
        *,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> "InterfaceVpcEndpoint":
        '''Adds a new interface endpoint to this VPC.

        :param id: -
        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__00d64fd969958beb796ccf5d1bc5d808fd3e751c9e3c2237abfaf2dbe5615a46)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = InterfaceVpcEndpointOptions(
            service=service,
            lookup_supported_azs=lookup_supported_azs,
            open=open,
            private_dns_enabled=private_dns_enabled,
            security_groups=security_groups,
            subnets=subnets,
        )

        return typing.cast("InterfaceVpcEndpoint", jsii.invoke(self, "addInterfaceEndpoint", [id, options]))

    @jsii.member(jsii_name="addVpnConnection")
    def add_vpn_connection(
        self,
        id: builtins.str,
        *,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union["VpnTunnelOption", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> "VpnConnection":
        '''Adds a new VPN connection to this VPC.

        :param id: -
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0cc11c2e24387d8a6e5c604fc955974dec83a9a5fc83514fe6bf8d3bc0efaf74)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = VpnConnectionOptions(
            ip=ip, asn=asn, static_routes=static_routes, tunnel_options=tunnel_options
        )

        return typing.cast("VpnConnection", jsii.invoke(self, "addVpnConnection", [id, options]))

    @jsii.member(jsii_name="enableVpnGateway")
    def enable_vpn_gateway(
        self,
        *,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''Adds a VPN Gateway to this VPC.

        :param vpn_route_propagation: Provide an array of subnets where the route propagation should be added. Default: noPropagation
        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000
        '''
        options = EnableVpnGatewayOptions(
            vpn_route_propagation=vpn_route_propagation,
            type=type,
            amazon_side_asn=amazon_side_asn,
        )

        return typing.cast(None, jsii.invoke(self, "enableVpnGateway", [options]))

    @jsii.member(jsii_name="selectSubnetObjects")
    def _select_subnet_objects(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence[SubnetFilter]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional[SubnetType] = None,
    ) -> typing.List[ISubnet]:
        '''Return the subnets appropriate for the placement strategy.

        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        selection = SubnetSelection(
            availability_zones=availability_zones,
            one_per_az=one_per_az,
            subnet_filters=subnet_filters,
            subnet_group_name=subnet_group_name,
            subnets=subnets,
            subnet_type=subnet_type,
        )

        return typing.cast(typing.List[ISubnet], jsii.invoke(self, "selectSubnetObjects", [selection]))

    @jsii.member(jsii_name="selectSubnets")
    def select_subnets(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        one_per_az: typing.Optional[builtins.bool] = None,
        subnet_filters: typing.Optional[typing.Sequence[SubnetFilter]] = None,
        subnet_group_name: typing.Optional[builtins.str] = None,
        subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
        subnet_type: typing.Optional[SubnetType] = None,
    ) -> SelectedSubnets:
        '''Returns IDs of selected subnets.

        :param availability_zones: Select subnets only in the given AZs. Default: no filtering on AZs is done
        :param one_per_az: If true, return at most one subnet per AZ. Default: false
        :param subnet_filters: List of provided subnet filters. Default: - none
        :param subnet_group_name: Select the subnet group with the given name. Select the subnet group with the given name. This only needs to be used if you have multiple subnet groups of the same type and you need to distinguish between them. Otherwise, prefer ``subnetType``. This field does not select individual subnets, it selects all subnets that share the given subnet group name. This is the name supplied in ``subnetConfiguration``. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: - Selection by type instead of by name
        :param subnets: Explicitly select individual subnets. Use this if you don't want to automatically use all subnets in a group, but have a need to control selection down to individual subnets. Cannot be specified together with ``subnetType`` or ``subnetGroupName``. Default: - Use all subnets in a selected group (all private subnets by default)
        :param subnet_type: Select all subnets of the given type. At most one of ``subnetType`` and ``subnetGroupName`` can be supplied. Default: SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)
        '''
        selection = SubnetSelection(
            availability_zones=availability_zones,
            one_per_az=one_per_az,
            subnet_filters=subnet_filters,
            subnet_group_name=subnet_group_name,
            subnets=subnets,
            subnet_type=subnet_type,
        )

        return typing.cast(SelectedSubnets, jsii.invoke(self, "selectSubnets", [selection]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_CIDR_RANGE")
    def DEFAULT_CIDR_RANGE(cls) -> builtins.str:
        '''The default CIDR range used when creating VPCs.

        This can be overridden using VpcProps when creating a VPCNetwork resource.
        e.g. new VpcResource(this, { cidr: '192.168.0.0./16' })

        Note this is specific to the IPv4 CIDR.
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_CIDR_RANGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_SUBNETS")
    def DEFAULT_SUBNETS(cls) -> typing.List[SubnetConfiguration]:
        '''The default subnet configuration.

        1 Public and 1 Private subnet per AZ evenly split
        '''
        return typing.cast(typing.List[SubnetConfiguration], jsii.sget(cls, "DEFAULT_SUBNETS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_SUBNETS_NO_NAT")
    def DEFAULT_SUBNETS_NO_NAT(cls) -> typing.List[SubnetConfiguration]:
        '''The default subnet configuration if natGateways specified to be 0.

        1 Public and 1 Isolated Subnet per AZ evenly split
        '''
        return typing.cast(typing.List[SubnetConfiguration], jsii.sget(cls, "DEFAULT_SUBNETS_NO_NAT"))

    @builtins.property
    @jsii.member(jsii_name="availabilityZones")
    def availability_zones(self) -> typing.List[builtins.str]:
        '''AZs for this VPC.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "availabilityZones"))

    @builtins.property
    @jsii.member(jsii_name="dnsHostnamesEnabled")
    def dns_hostnames_enabled(self) -> builtins.bool:
        '''Indicates if instances launched in this VPC will have public DNS hostnames.'''
        return typing.cast(builtins.bool, jsii.get(self, "dnsHostnamesEnabled"))

    @builtins.property
    @jsii.member(jsii_name="dnsSupportEnabled")
    def dns_support_enabled(self) -> builtins.bool:
        '''Indicates if DNS support is enabled for this VPC.'''
        return typing.cast(builtins.bool, jsii.get(self, "dnsSupportEnabled"))

    @builtins.property
    @jsii.member(jsii_name="internetConnectivityEstablished")
    def internet_connectivity_established(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependencies for internet connectivity.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "internetConnectivityEstablished"))

    @builtins.property
    @jsii.member(jsii_name="isolatedSubnets")
    def isolated_subnets(self) -> typing.List[ISubnet]:
        '''List of isolated subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "isolatedSubnets"))

    @builtins.property
    @jsii.member(jsii_name="privateSubnets")
    def private_subnets(self) -> typing.List[ISubnet]:
        '''List of private subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "privateSubnets"))

    @builtins.property
    @jsii.member(jsii_name="publicSubnets")
    def public_subnets(self) -> typing.List[ISubnet]:
        '''List of public subnets in this VPC.'''
        return typing.cast(typing.List[ISubnet], jsii.get(self, "publicSubnets"))

    @builtins.property
    @jsii.member(jsii_name="vpcArn")
    def vpc_arn(self) -> builtins.str:
        '''Arn of this VPC.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcArn"))

    @builtins.property
    @jsii.member(jsii_name="vpcCidrBlock")
    def vpc_cidr_block(self) -> builtins.str:
        '''CIDR range for this VPC.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcCidrBlock"))

    @builtins.property
    @jsii.member(jsii_name="vpcCidrBlockAssociations")
    def vpc_cidr_block_associations(self) -> typing.List[builtins.str]:
        '''
        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcCidrBlockAssociations"))

    @builtins.property
    @jsii.member(jsii_name="vpcDefaultNetworkAcl")
    def vpc_default_network_acl(self) -> builtins.str:
        '''
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcDefaultNetworkAcl"))

    @builtins.property
    @jsii.member(jsii_name="vpcDefaultSecurityGroup")
    def vpc_default_security_group(self) -> builtins.str:
        '''
        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcDefaultSecurityGroup"))

    @builtins.property
    @jsii.member(jsii_name="vpcId")
    def vpc_id(self) -> builtins.str:
        '''Identifier for this VPC.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcId"))

    @builtins.property
    @jsii.member(jsii_name="vpcIpv6CidrBlocks")
    def vpc_ipv6_cidr_blocks(self) -> typing.List[builtins.str]:
        '''
        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcIpv6CidrBlocks"))

    @builtins.property
    @jsii.member(jsii_name="internetGatewayId")
    def internet_gateway_id(self) -> typing.Optional[builtins.str]:
        '''Internet Gateway for the VPC.

        Note that in case the VPC is configured only
        with ISOLATED subnets, this attribute will be ``undefined``.
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "internetGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="vpnGatewayId")
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''Returns the id of the VPN Gateway (if enabled).'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "vpnGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="incompleteSubnetDefinition")
    def _incomplete_subnet_definition(self) -> builtins.bool:
        '''If this is set to true, don't error out on trying to select subnets.'''
        return typing.cast(builtins.bool, jsii.get(self, "incompleteSubnetDefinition"))

    @_incomplete_subnet_definition.setter
    def _incomplete_subnet_definition(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__579c5c37f3ad43ef55c8403784c0f02c2cc55c98b4122bb2058b45c27041bc73)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "incompleteSubnetDefinition", value)


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpcAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zones": "availabilityZones",
        "vpc_id": "vpcId",
        "isolated_subnet_ids": "isolatedSubnetIds",
        "isolated_subnet_ipv4_cidr_blocks": "isolatedSubnetIpv4CidrBlocks",
        "isolated_subnet_names": "isolatedSubnetNames",
        "isolated_subnet_route_table_ids": "isolatedSubnetRouteTableIds",
        "private_subnet_ids": "privateSubnetIds",
        "private_subnet_ipv4_cidr_blocks": "privateSubnetIpv4CidrBlocks",
        "private_subnet_names": "privateSubnetNames",
        "private_subnet_route_table_ids": "privateSubnetRouteTableIds",
        "public_subnet_ids": "publicSubnetIds",
        "public_subnet_ipv4_cidr_blocks": "publicSubnetIpv4CidrBlocks",
        "public_subnet_names": "publicSubnetNames",
        "public_subnet_route_table_ids": "publicSubnetRouteTableIds",
        "region": "region",
        "vpc_cidr_block": "vpcCidrBlock",
        "vpn_gateway_id": "vpnGatewayId",
    },
)
class VpcAttributes:
    def __init__(
        self,
        *,
        availability_zones: typing.Sequence[builtins.str],
        vpc_id: builtins.str,
        isolated_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        isolated_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        private_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
        public_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
        region: typing.Optional[builtins.str] = None,
        vpc_cidr_block: typing.Optional[builtins.str] = None,
        vpn_gateway_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties that reference an external Vpc.

        :param availability_zones: List of availability zones for the subnets in this VPC.
        :param vpc_id: VPC's identifier.
        :param isolated_subnet_ids: List of isolated subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any isolated subnets
        :param isolated_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the isolated subnets. Must be undefined or have an entry for every isolated subnet group. Default: - Retrieving the IPv4 CIDR block of any isolated subnet will fail
        :param isolated_subnet_names: List of names for the isolated subnets. Must be undefined or have a name for every isolated subnet group. Default: - All isolated subnets will have the name ``Isolated``
        :param isolated_subnet_route_table_ids: List of IDs of route tables for the isolated subnets. Must be undefined or have a name for every isolated subnet group. Default: - Retrieving the route table ID of any isolated subnet will fail
        :param private_subnet_ids: List of private subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any private subnets
        :param private_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the private subnets. Must be undefined or have an entry for every private subnet group. Default: - Retrieving the IPv4 CIDR block of any private subnet will fail
        :param private_subnet_names: List of names for the private subnets. Must be undefined or have a name for every private subnet group. Default: - All private subnets will have the name ``Private``
        :param private_subnet_route_table_ids: List of IDs of route tables for the private subnets. Must be undefined or have a name for every private subnet group. Default: - Retrieving the route table ID of any private subnet will fail
        :param public_subnet_ids: List of public subnet IDs. Must be undefined or match the availability zones in length and order. Default: - The VPC does not have any public subnets
        :param public_subnet_ipv4_cidr_blocks: List of IPv4 CIDR blocks for the public subnets. Must be undefined or have an entry for every public subnet group. Default: - Retrieving the IPv4 CIDR block of any public subnet will fail
        :param public_subnet_names: List of names for the public subnets. Must be undefined or have a name for every public subnet group. Default: - All public subnets will have the name ``Public``
        :param public_subnet_route_table_ids: List of IDs of route tables for the public subnets. Must be undefined or have a name for every public subnet group. Default: - Retrieving the route table ID of any public subnet will fail
        :param region: The region the VPC is in. Default: - The region of the stack where the VPC belongs to
        :param vpc_cidr_block: VPC's CIDR range. Default: - Retrieving the CIDR from the VPC will fail
        :param vpn_gateway_id: VPN gateway's identifier.

        :exampleMetadata: infused

        Example::

            vpc = ec2.Vpc.from_vpc_attributes(self, "VPC",
                vpc_id="vpc-1234",
                availability_zones=["us-east-1a", "us-east-1b"],
            
                # Either pass literals for all IDs
                public_subnet_ids=["s-12345", "s-67890"],
            
                # OR: import a list of known length
                private_subnet_ids=Fn.import_list_value("PrivateSubnetIds", 2),
            
                # OR: split an imported string to a list of known length
                isolated_subnet_ids=Fn.split(",", ssm.StringParameter.value_for_string_parameter(self, "MyParameter"), 2)
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fa6d457cb5653a868580011d362ed0a19c899333d9fd8d459bec785f98897e2e)
            check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument isolated_subnet_ids", value=isolated_subnet_ids, expected_type=type_hints["isolated_subnet_ids"])
            check_type(argname="argument isolated_subnet_ipv4_cidr_blocks", value=isolated_subnet_ipv4_cidr_blocks, expected_type=type_hints["isolated_subnet_ipv4_cidr_blocks"])
            check_type(argname="argument isolated_subnet_names", value=isolated_subnet_names, expected_type=type_hints["isolated_subnet_names"])
            check_type(argname="argument isolated_subnet_route_table_ids", value=isolated_subnet_route_table_ids, expected_type=type_hints["isolated_subnet_route_table_ids"])
            check_type(argname="argument private_subnet_ids", value=private_subnet_ids, expected_type=type_hints["private_subnet_ids"])
            check_type(argname="argument private_subnet_ipv4_cidr_blocks", value=private_subnet_ipv4_cidr_blocks, expected_type=type_hints["private_subnet_ipv4_cidr_blocks"])
            check_type(argname="argument private_subnet_names", value=private_subnet_names, expected_type=type_hints["private_subnet_names"])
            check_type(argname="argument private_subnet_route_table_ids", value=private_subnet_route_table_ids, expected_type=type_hints["private_subnet_route_table_ids"])
            check_type(argname="argument public_subnet_ids", value=public_subnet_ids, expected_type=type_hints["public_subnet_ids"])
            check_type(argname="argument public_subnet_ipv4_cidr_blocks", value=public_subnet_ipv4_cidr_blocks, expected_type=type_hints["public_subnet_ipv4_cidr_blocks"])
            check_type(argname="argument public_subnet_names", value=public_subnet_names, expected_type=type_hints["public_subnet_names"])
            check_type(argname="argument public_subnet_route_table_ids", value=public_subnet_route_table_ids, expected_type=type_hints["public_subnet_route_table_ids"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument vpc_cidr_block", value=vpc_cidr_block, expected_type=type_hints["vpc_cidr_block"])
            check_type(argname="argument vpn_gateway_id", value=vpn_gateway_id, expected_type=type_hints["vpn_gateway_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zones": availability_zones,
            "vpc_id": vpc_id,
        }
        if isolated_subnet_ids is not None:
            self._values["isolated_subnet_ids"] = isolated_subnet_ids
        if isolated_subnet_ipv4_cidr_blocks is not None:
            self._values["isolated_subnet_ipv4_cidr_blocks"] = isolated_subnet_ipv4_cidr_blocks
        if isolated_subnet_names is not None:
            self._values["isolated_subnet_names"] = isolated_subnet_names
        if isolated_subnet_route_table_ids is not None:
            self._values["isolated_subnet_route_table_ids"] = isolated_subnet_route_table_ids
        if private_subnet_ids is not None:
            self._values["private_subnet_ids"] = private_subnet_ids
        if private_subnet_ipv4_cidr_blocks is not None:
            self._values["private_subnet_ipv4_cidr_blocks"] = private_subnet_ipv4_cidr_blocks
        if private_subnet_names is not None:
            self._values["private_subnet_names"] = private_subnet_names
        if private_subnet_route_table_ids is not None:
            self._values["private_subnet_route_table_ids"] = private_subnet_route_table_ids
        if public_subnet_ids is not None:
            self._values["public_subnet_ids"] = public_subnet_ids
        if public_subnet_ipv4_cidr_blocks is not None:
            self._values["public_subnet_ipv4_cidr_blocks"] = public_subnet_ipv4_cidr_blocks
        if public_subnet_names is not None:
            self._values["public_subnet_names"] = public_subnet_names
        if public_subnet_route_table_ids is not None:
            self._values["public_subnet_route_table_ids"] = public_subnet_route_table_ids
        if region is not None:
            self._values["region"] = region
        if vpc_cidr_block is not None:
            self._values["vpc_cidr_block"] = vpc_cidr_block
        if vpn_gateway_id is not None:
            self._values["vpn_gateway_id"] = vpn_gateway_id

    @builtins.property
    def availability_zones(self) -> typing.List[builtins.str]:
        '''List of availability zones for the subnets in this VPC.'''
        result = self._values.get("availability_zones")
        assert result is not None, "Required property 'availability_zones' is missing"
        return typing.cast(typing.List[builtins.str], result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''VPC's identifier.'''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def isolated_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of isolated subnet IDs.

        Must be undefined or match the availability zones in length and order.

        :default: - The VPC does not have any isolated subnets
        '''
        result = self._values.get("isolated_subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def isolated_subnet_ipv4_cidr_blocks(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IPv4 CIDR blocks for the isolated subnets.

        Must be undefined or have an entry for every isolated subnet group.

        :default: - Retrieving the IPv4 CIDR block of any isolated subnet will fail
        '''
        result = self._values.get("isolated_subnet_ipv4_cidr_blocks")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def isolated_subnet_names(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of names for the isolated subnets.

        Must be undefined or have a name for every isolated subnet group.

        :default: - All isolated subnets will have the name ``Isolated``
        '''
        result = self._values.get("isolated_subnet_names")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def isolated_subnet_route_table_ids(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IDs of route tables for the isolated subnets.

        Must be undefined or have a name for every isolated subnet group.

        :default: - Retrieving the route table ID of any isolated subnet will fail
        '''
        result = self._values.get("isolated_subnet_route_table_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def private_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of private subnet IDs.

        Must be undefined or match the availability zones in length and order.

        :default: - The VPC does not have any private subnets
        '''
        result = self._values.get("private_subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def private_subnet_ipv4_cidr_blocks(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IPv4 CIDR blocks for the private subnets.

        Must be undefined or have an entry for every private subnet group.

        :default: - Retrieving the IPv4 CIDR block of any private subnet will fail
        '''
        result = self._values.get("private_subnet_ipv4_cidr_blocks")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def private_subnet_names(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of names for the private subnets.

        Must be undefined or have a name for every private subnet group.

        :default: - All private subnets will have the name ``Private``
        '''
        result = self._values.get("private_subnet_names")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def private_subnet_route_table_ids(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IDs of route tables for the private subnets.

        Must be undefined or have a name for every private subnet group.

        :default: - Retrieving the route table ID of any private subnet will fail
        '''
        result = self._values.get("private_subnet_route_table_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def public_subnet_ids(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of public subnet IDs.

        Must be undefined or match the availability zones in length and order.

        :default: - The VPC does not have any public subnets
        '''
        result = self._values.get("public_subnet_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def public_subnet_ipv4_cidr_blocks(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IPv4 CIDR blocks for the public subnets.

        Must be undefined or have an entry for every public subnet group.

        :default: - Retrieving the IPv4 CIDR block of any public subnet will fail
        '''
        result = self._values.get("public_subnet_ipv4_cidr_blocks")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def public_subnet_names(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of names for the public subnets.

        Must be undefined or have a name for every public subnet group.

        :default: - All public subnets will have the name ``Public``
        '''
        result = self._values.get("public_subnet_names")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def public_subnet_route_table_ids(
        self,
    ) -> typing.Optional[typing.List[builtins.str]]:
        '''List of IDs of route tables for the public subnets.

        Must be undefined or have a name for every public subnet group.

        :default: - Retrieving the route table ID of any public subnet will fail
        '''
        result = self._values.get("public_subnet_route_table_ids")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''The region the VPC is in.

        :default: - The region of the stack where the VPC belongs to
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_cidr_block(self) -> typing.Optional[builtins.str]:
        '''VPC's CIDR range.

        :default: - Retrieving the CIDR from the VPC will fail
        '''
        result = self._values.get("vpc_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
        '''VPN gateway's identifier.'''
        result = self._values.get("vpn_gateway_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpcAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IVpcEndpoint)
class VpcEndpoint(
    _Resource_45bc6135,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.VpcEndpoint",
):
    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        environment_from_arn: typing.Optional[builtins.str] = None,
        physical_name: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param account: The AWS account ID this resource belongs to. Default: - the resource is in the same account as the stack it belongs to
        :param environment_from_arn: ARN to deduce region and account from. The ARN is parsed and the account and region are taken from the ARN. This should be used for imported resources. Cannot be supplied together with either ``account`` or ``region``. Default: - take environment from ``account``, ``region`` parameters, or use Stack environment.
        :param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated by CloudFormation during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation. Default: - The physical name will be allocated by CloudFormation at deployment time
        :param region: The AWS region this resource belongs to. Default: - the resource is in the same region as the stack it belongs to
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ca644de10a5f135db39c62e89d37ce660164addf9000f9ca56fb5e67a35f481)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _ResourceProps_15a65b4e(
            account=account,
            environment_from_arn=environment_from_arn,
            physical_name=physical_name,
            region=region,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="addToPolicy")
    def add_to_policy(self, statement: _PolicyStatement_0fe33853) -> None:
        '''Adds a statement to the policy document of the VPC endpoint. The statement must have a Principal.

        Not all interface VPC endpoints support policy. For more information
        see https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html

        :param statement: the IAM statement to add.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8bc776f89a26beb5c4a733c459442d569ed75b61853b97f02881d59985e22463)
            check_type(argname="argument statement", value=statement, expected_type=type_hints["statement"])
        return typing.cast(None, jsii.invoke(self, "addToPolicy", [statement]))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    @abc.abstractmethod
    def vpc_endpoint_id(self) -> builtins.str:
        '''The VPC endpoint identifier.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="policyDocument")
    def _policy_document(self) -> typing.Optional[_PolicyDocument_3ac34393]:
        return typing.cast(typing.Optional[_PolicyDocument_3ac34393], jsii.get(self, "policyDocument"))

    @_policy_document.setter
    def _policy_document(
        self,
        value: typing.Optional[_PolicyDocument_3ac34393],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__47cfcdd89628cfb671a1d60301cde8a7bfb3bf964b2818f24cf3544b41cb83a8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "policyDocument", value)


class _VpcEndpointProxy(
    VpcEndpoint,
    jsii.proxy_for(_Resource_45bc6135), # type: ignore[misc]
):
    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> builtins.str:
        '''The VPC endpoint identifier.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, VpcEndpoint).__jsii_proxy_class__ = lambda : _VpcEndpointProxy


@jsii.implements(IVpcEndpointService)
class VpcEndpointService(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.VpcEndpointService",
):
    '''A VPC endpoint service.

    :resource: AWS::EC2::VPCEndpointService
    :exampleMetadata: infused

    Example::

        # network_load_balancer1: elbv2.NetworkLoadBalancer
        # network_load_balancer2: elbv2.NetworkLoadBalancer
        
        
        ec2.VpcEndpointService(self, "EndpointService",
            vpc_endpoint_service_load_balancers=[network_load_balancer1, network_load_balancer2],
            acceptance_required=True,
            allowed_principals=[iam.ArnPrincipal("arn:aws:iam::123456789012:root")],
            contributor_insights=True
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc_endpoint_service_load_balancers: typing.Sequence[IVpcEndpointServiceLoadBalancer],
        acceptance_required: typing.Optional[builtins.bool] = None,
        allowed_principals: typing.Optional[typing.Sequence[_ArnPrincipal_d31ca6bc]] = None,
        contributor_insights: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc_endpoint_service_load_balancers: One or more load balancers to host the VPC Endpoint Service.
        :param acceptance_required: Whether requests from service consumers to connect to the service through an endpoint must be accepted. Default: true
        :param allowed_principals: IAM users, IAM roles, or AWS accounts to allow inbound connections from. These principals can connect to your service using VPC endpoints. Takes a list of one or more ArnPrincipal. Default: - no principals
        :param contributor_insights: Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink. Default: false
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e9a177a308c941d9422cff7194d8a56d967004d3230efd826dc934ef5358129e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = VpcEndpointServiceProps(
            vpc_endpoint_service_load_balancers=vpc_endpoint_service_load_balancers,
            acceptance_required=acceptance_required,
            allowed_principals=allowed_principals,
            contributor_insights=contributor_insights,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="acceptanceRequired")
    def acceptance_required(self) -> builtins.bool:
        '''Whether to require manual acceptance of new connections to the service.'''
        return typing.cast(builtins.bool, jsii.get(self, "acceptanceRequired"))

    @builtins.property
    @jsii.member(jsii_name="allowedPrincipals")
    def allowed_principals(self) -> typing.List[_ArnPrincipal_d31ca6bc]:
        '''One or more Principal ARNs to allow inbound connections to.'''
        return typing.cast(typing.List[_ArnPrincipal_d31ca6bc], jsii.get(self, "allowedPrincipals"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceId")
    def vpc_endpoint_service_id(self) -> builtins.str:
        '''The id of the VPC Endpoint Service, like vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointServiceId"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceLoadBalancers")
    def vpc_endpoint_service_load_balancers(
        self,
    ) -> typing.List[IVpcEndpointServiceLoadBalancer]:
        '''One or more network load balancers to host the service.

        :attribute: true
        '''
        return typing.cast(typing.List[IVpcEndpointServiceLoadBalancer], jsii.get(self, "vpcEndpointServiceLoadBalancers"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> builtins.str:
        '''The service name of the VPC Endpoint Service that clients use to connect to, like com.amazonaws.vpce..vpce-svc-xxxxxxxxxxxxxxxx.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointServiceName"))

    @builtins.property
    @jsii.member(jsii_name="contributorInsightsEnabled")
    def contributor_insights_enabled(self) -> typing.Optional[builtins.bool]:
        '''Whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "contributorInsightsEnabled"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpcEndpointServiceProps",
    jsii_struct_bases=[],
    name_mapping={
        "vpc_endpoint_service_load_balancers": "vpcEndpointServiceLoadBalancers",
        "acceptance_required": "acceptanceRequired",
        "allowed_principals": "allowedPrincipals",
        "contributor_insights": "contributorInsights",
    },
)
class VpcEndpointServiceProps:
    def __init__(
        self,
        *,
        vpc_endpoint_service_load_balancers: typing.Sequence[IVpcEndpointServiceLoadBalancer],
        acceptance_required: typing.Optional[builtins.bool] = None,
        allowed_principals: typing.Optional[typing.Sequence[_ArnPrincipal_d31ca6bc]] = None,
        contributor_insights: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Construction properties for a VpcEndpointService.

        :param vpc_endpoint_service_load_balancers: One or more load balancers to host the VPC Endpoint Service.
        :param acceptance_required: Whether requests from service consumers to connect to the service through an endpoint must be accepted. Default: true
        :param allowed_principals: IAM users, IAM roles, or AWS accounts to allow inbound connections from. These principals can connect to your service using VPC endpoints. Takes a list of one or more ArnPrincipal. Default: - no principals
        :param contributor_insights: Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink. Default: false

        :exampleMetadata: infused

        Example::

            # network_load_balancer1: elbv2.NetworkLoadBalancer
            # network_load_balancer2: elbv2.NetworkLoadBalancer
            
            
            ec2.VpcEndpointService(self, "EndpointService",
                vpc_endpoint_service_load_balancers=[network_load_balancer1, network_load_balancer2],
                acceptance_required=True,
                allowed_principals=[iam.ArnPrincipal("arn:aws:iam::123456789012:root")],
                contributor_insights=True
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c8d3e17059165270b27192911c5b63d78564836ce9d6a1d2e41f5d272b4c7df6)
            check_type(argname="argument vpc_endpoint_service_load_balancers", value=vpc_endpoint_service_load_balancers, expected_type=type_hints["vpc_endpoint_service_load_balancers"])
            check_type(argname="argument acceptance_required", value=acceptance_required, expected_type=type_hints["acceptance_required"])
            check_type(argname="argument allowed_principals", value=allowed_principals, expected_type=type_hints["allowed_principals"])
            check_type(argname="argument contributor_insights", value=contributor_insights, expected_type=type_hints["contributor_insights"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "vpc_endpoint_service_load_balancers": vpc_endpoint_service_load_balancers,
        }
        if acceptance_required is not None:
            self._values["acceptance_required"] = acceptance_required
        if allowed_principals is not None:
            self._values["allowed_principals"] = allowed_principals
        if contributor_insights is not None:
            self._values["contributor_insights"] = contributor_insights

    @builtins.property
    def vpc_endpoint_service_load_balancers(
        self,
    ) -> typing.List[IVpcEndpointServiceLoadBalancer]:
        '''One or more load balancers to host the VPC Endpoint Service.'''
        result = self._values.get("vpc_endpoint_service_load_balancers")
        assert result is not None, "Required property 'vpc_endpoint_service_load_balancers' is missing"
        return typing.cast(typing.List[IVpcEndpointServiceLoadBalancer], result)

    @builtins.property
    def acceptance_required(self) -> typing.Optional[builtins.bool]:
        '''Whether requests from service consumers to connect to the service through an endpoint must be accepted.

        :default: true
        '''
        result = self._values.get("acceptance_required")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def allowed_principals(
        self,
    ) -> typing.Optional[typing.List[_ArnPrincipal_d31ca6bc]]:
        '''IAM users, IAM roles, or AWS accounts to allow inbound connections from.

        These principals can connect to your service using VPC endpoints. Takes a
        list of one or more ArnPrincipal.

        :default: - no principals
        '''
        result = self._values.get("allowed_principals")
        return typing.cast(typing.Optional[typing.List[_ArnPrincipal_d31ca6bc]], result)

    @builtins.property
    def contributor_insights(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink.

        :default: false
        '''
        result = self._values.get("contributor_insights")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpcEndpointServiceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.VpcEndpointType")
class VpcEndpointType(enum.Enum):
    '''The type of VPC endpoint.'''

    INTERFACE = "INTERFACE"
    '''Interface.

    An interface endpoint is an elastic network interface with a private IP
    address that serves as an entry point for traffic destined to a supported
    service.
    '''
    GATEWAY = "GATEWAY"
    '''Gateway.

    A gateway endpoint is a gateway that is a target for a specified route in
    your route table, used for traffic destined to a supported AWS service.
    '''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpcIpamOptions",
    jsii_struct_bases=[],
    name_mapping={
        "cidr_block": "cidrBlock",
        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
        "ipv4_netmask_length": "ipv4NetmaskLength",
    },
)
class VpcIpamOptions:
    def __init__(
        self,
        *,
        cidr_block: typing.Optional[builtins.str] = None,
        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''CIDR Allocated Vpc.

        :param cidr_block: CIDR Block for Vpc. Default: - Only required when Ipam has concrete allocation available for static Vpc
        :param ipv4_ipam_pool_id: ipv4 IPAM Pool Id. Default: - Only required when using AWS Ipam
        :param ipv4_netmask_length: CIDR Mask for Vpc. Default: - Only required when using AWS Ipam

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            vpc_ipam_options = ec2.VpcIpamOptions(
                cidr_block="cidrBlock",
                ipv4_ipam_pool_id="ipv4IpamPoolId",
                ipv4_netmask_length=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7730c6b5e42eef600984c48409266eac006c223fb60969799a2d31f3fc5f613b)
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument ipv4_ipam_pool_id", value=ipv4_ipam_pool_id, expected_type=type_hints["ipv4_ipam_pool_id"])
            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cidr_block is not None:
            self._values["cidr_block"] = cidr_block
        if ipv4_ipam_pool_id is not None:
            self._values["ipv4_ipam_pool_id"] = ipv4_ipam_pool_id
        if ipv4_netmask_length is not None:
            self._values["ipv4_netmask_length"] = ipv4_netmask_length

    @builtins.property
    def cidr_block(self) -> typing.Optional[builtins.str]:
        '''CIDR Block for Vpc.

        :default: - Only required when Ipam has concrete allocation available for static Vpc
        '''
        result = self._values.get("cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
        '''ipv4 IPAM Pool Id.

        :default: - Only required when using AWS Ipam
        '''
        result = self._values.get("ipv4_ipam_pool_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
        '''CIDR Mask for Vpc.

        :default: - Only required when using AWS Ipam
        '''
        result = self._values.get("ipv4_netmask_length")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpcIpamOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpcLookupOptions",
    jsii_struct_bases=[],
    name_mapping={
        "is_default": "isDefault",
        "owner_account_id": "ownerAccountId",
        "region": "region",
        "return_vpn_gateways": "returnVpnGateways",
        "subnet_group_name_tag": "subnetGroupNameTag",
        "tags": "tags",
        "vpc_id": "vpcId",
        "vpc_name": "vpcName",
    },
)
class VpcLookupOptions:
    def __init__(
        self,
        *,
        is_default: typing.Optional[builtins.bool] = None,
        owner_account_id: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        return_vpn_gateways: typing.Optional[builtins.bool] = None,
        subnet_group_name_tag: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        vpc_id: typing.Optional[builtins.str] = None,
        vpc_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties for looking up an existing VPC.

        The combination of properties must specify filter down to exactly one
        non-default VPC, otherwise an error is raised.

        :param is_default: Whether to match the default VPC. Default: Don't care whether we return the default VPC
        :param owner_account_id: The ID of the AWS account that owns the VPC. Default: the account id of the parent stack
        :param region: Optional to override inferred region. Default: Current stack's environment region
        :param return_vpn_gateways: Whether to look up whether a VPN Gateway is attached to the looked up VPC. You can set this to ``false`` if you know the VPC does not have a VPN Gateway attached, in order to avoid an API call. If you change this property from ``false`` to ``true`` or undefined, you may need to clear the corresponding context entry in ``cdk.context.json`` in order to trigger a new lookup. Default: true
        :param subnet_group_name_tag: Optional tag for subnet group name. If not provided, we'll look at the aws-cdk:subnet-name tag. If the subnet does not have the specified tag, we'll use its type as the name. Default: aws-cdk:subnet-name
        :param tags: Tags on the VPC. The VPC must have all of these tags Default: Don't filter on tags
        :param vpc_id: The ID of the VPC. If given, will import exactly this VPC. Default: Don't filter on vpcId
        :param vpc_name: The name of the VPC. If given, will import the VPC with this name. Default: Don't filter on vpcName

        :exampleMetadata: infused

        Example::

            # create a cloud9 ec2 environment in a new VPC
            vpc = ec2.Vpc(self, "VPC", max_azs=3)
            cloud9.Ec2Environment(self, "Cloud9Env", vpc=vpc, image_id=cloud9.ImageId.AMAZON_LINUX_2)
            
            # or create the cloud9 environment in the default VPC with specific instanceType
            default_vpc = ec2.Vpc.from_lookup(self, "DefaultVPC", is_default=True)
            cloud9.Ec2Environment(self, "Cloud9Env2",
                vpc=default_vpc,
                instance_type=ec2.InstanceType("t3.large"),
                image_id=cloud9.ImageId.AMAZON_LINUX_2
            )
            
            # or specify in a different subnetSelection
            c9env = cloud9.Ec2Environment(self, "Cloud9Env3",
                vpc=vpc,
                subnet_selection=ec2.SubnetSelection(
                    subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
                ),
                image_id=cloud9.ImageId.AMAZON_LINUX_2
            )
            
            # print the Cloud9 IDE URL in the output
            CfnOutput(self, "URL", value=c9env.ide_url)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dff7b53f348ae2cf7efc93ce0f0df35bcb1e7b1b64b7b8a6c57a9924d14268ae)
            check_type(argname="argument is_default", value=is_default, expected_type=type_hints["is_default"])
            check_type(argname="argument owner_account_id", value=owner_account_id, expected_type=type_hints["owner_account_id"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument return_vpn_gateways", value=return_vpn_gateways, expected_type=type_hints["return_vpn_gateways"])
            check_type(argname="argument subnet_group_name_tag", value=subnet_group_name_tag, expected_type=type_hints["subnet_group_name_tag"])
            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument vpc_name", value=vpc_name, expected_type=type_hints["vpc_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if is_default is not None:
            self._values["is_default"] = is_default
        if owner_account_id is not None:
            self._values["owner_account_id"] = owner_account_id
        if region is not None:
            self._values["region"] = region
        if return_vpn_gateways is not None:
            self._values["return_vpn_gateways"] = return_vpn_gateways
        if subnet_group_name_tag is not None:
            self._values["subnet_group_name_tag"] = subnet_group_name_tag
        if tags is not None:
            self._values["tags"] = tags
        if vpc_id is not None:
            self._values["vpc_id"] = vpc_id
        if vpc_name is not None:
            self._values["vpc_name"] = vpc_name

    @builtins.property
    def is_default(self) -> typing.Optional[builtins.bool]:
        '''Whether to match the default VPC.

        :default: Don't care whether we return the default VPC
        '''
        result = self._values.get("is_default")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def owner_account_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the AWS account that owns the VPC.

        :default: the account id of the parent stack
        '''
        result = self._values.get("owner_account_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def region(self) -> typing.Optional[builtins.str]:
        '''Optional to override inferred region.

        :default: Current stack's environment region
        '''
        result = self._values.get("region")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def return_vpn_gateways(self) -> typing.Optional[builtins.bool]:
        '''Whether to look up whether a VPN Gateway is attached to the looked up VPC.

        You can set this to ``false`` if you know the VPC does not have a VPN Gateway
        attached, in order to avoid an API call.

        If you change this property from ``false`` to ``true`` or undefined, you may
        need to clear the corresponding context entry in ``cdk.context.json`` in
        order to trigger a new lookup.

        :default: true
        '''
        result = self._values.get("return_vpn_gateways")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subnet_group_name_tag(self) -> typing.Optional[builtins.str]:
        '''Optional tag for subnet group name.

        If not provided, we'll look at the aws-cdk:subnet-name tag.
        If the subnet does not have the specified tag,
        we'll use its type as the name.

        :default: aws-cdk:subnet-name
        '''
        result = self._values.get("subnet_group_name_tag")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
        '''Tags on the VPC.

        The VPC must have all of these tags

        :default: Don't filter on tags
        '''
        result = self._values.get("tags")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)

    @builtins.property
    def vpc_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the VPC.

        If given, will import exactly this VPC.

        :default: Don't filter on vpcId
        '''
        result = self._values.get("vpc_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpc_name(self) -> typing.Optional[builtins.str]:
        '''The name of the VPC.

        If given, will import the VPC with this name.

        :default: Don't filter on vpcName
        '''
        result = self._values.get("vpc_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpcLookupOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpcProps",
    jsii_struct_bases=[],
    name_mapping={
        "availability_zones": "availabilityZones",
        "cidr": "cidr",
        "create_internet_gateway": "createInternetGateway",
        "default_instance_tenancy": "defaultInstanceTenancy",
        "enable_dns_hostnames": "enableDnsHostnames",
        "enable_dns_support": "enableDnsSupport",
        "flow_logs": "flowLogs",
        "gateway_endpoints": "gatewayEndpoints",
        "ip_addresses": "ipAddresses",
        "ip_protocol": "ipProtocol",
        "ipv6_addresses": "ipv6Addresses",
        "max_azs": "maxAzs",
        "nat_gateway_provider": "natGatewayProvider",
        "nat_gateways": "natGateways",
        "nat_gateway_subnets": "natGatewaySubnets",
        "reserved_azs": "reservedAzs",
        "restrict_default_security_group": "restrictDefaultSecurityGroup",
        "subnet_configuration": "subnetConfiguration",
        "vpc_name": "vpcName",
        "vpn_connections": "vpnConnections",
        "vpn_gateway": "vpnGateway",
        "vpn_gateway_asn": "vpnGatewayAsn",
        "vpn_route_propagation": "vpnRoutePropagation",
    },
)
class VpcProps:
    def __init__(
        self,
        *,
        availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
        cidr: typing.Optional[builtins.str] = None,
        create_internet_gateway: typing.Optional[builtins.bool] = None,
        default_instance_tenancy: typing.Optional[DefaultInstanceTenancy] = None,
        enable_dns_hostnames: typing.Optional[builtins.bool] = None,
        enable_dns_support: typing.Optional[builtins.bool] = None,
        flow_logs: typing.Optional[typing.Mapping[builtins.str, typing.Union[FlowLogOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
        gateway_endpoints: typing.Optional[typing.Mapping[builtins.str, typing.Union[GatewayVpcEndpointOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
        ip_addresses: typing.Optional[IIpAddresses] = None,
        ip_protocol: typing.Optional[IpProtocol] = None,
        ipv6_addresses: typing.Optional[IIpv6Addresses] = None,
        max_azs: typing.Optional[jsii.Number] = None,
        nat_gateway_provider: typing.Optional[NatProvider] = None,
        nat_gateways: typing.Optional[jsii.Number] = None,
        nat_gateway_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
        reserved_azs: typing.Optional[jsii.Number] = None,
        restrict_default_security_group: typing.Optional[builtins.bool] = None,
        subnet_configuration: typing.Optional[typing.Sequence[typing.Union[SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_name: typing.Optional[builtins.str] = None,
        vpn_connections: typing.Optional[typing.Mapping[builtins.str, typing.Union["VpnConnectionOptions", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpn_gateway: typing.Optional[builtins.bool] = None,
        vpn_gateway_asn: typing.Optional[jsii.Number] = None,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Configuration for Vpc.

        :param availability_zones: Availability zones this VPC spans. Specify this option only if you do not specify ``maxAzs``. Default: - a subset of AZs of the stack
        :param cidr: (deprecated) The CIDR range to use for the VPC, e.g. '10.0.0.0/16'. Should be a minimum of /28 and maximum size of /16. The range will be split across all subnets per Availability Zone. Default: Vpc.DEFAULT_CIDR_RANGE
        :param create_internet_gateway: If set to false then disable the creation of the default internet gateway. Default: true
        :param default_instance_tenancy: The default tenancy of instances launched into the VPC. By setting this to dedicated tenancy, instances will be launched on hardware dedicated to a single AWS customer, unless specifically specified at instance launch time. Please note, not all instance types are usable with Dedicated tenancy. Default: DefaultInstanceTenancy.Default (shared) tenancy
        :param enable_dns_hostnames: Indicates whether the instances launched in the VPC get public DNS hostnames. If this attribute is true, instances in the VPC get public DNS hostnames, but only if the enableDnsSupport attribute is also set to true. Default: true
        :param enable_dns_support: Indicates whether the DNS resolution is supported for the VPC. If this attribute is false, the Amazon-provided DNS server in the VPC that resolves public DNS hostnames to IP addresses is not enabled. If this attribute is true, queries to the Amazon provided DNS server at the 169.254.169.253 IP address, or the reserved IP address at the base of the VPC IPv4 network range plus two will succeed. Default: true
        :param flow_logs: Flow logs to add to this VPC. Default: - No flow logs.
        :param gateway_endpoints: Gateway endpoints to add to this VPC. Default: - None.
        :param ip_addresses: The Provider to use to allocate IPv4 Space to your VPC. Options include static allocation or from a pool. Note this is specific to IPv4 addresses. Default: ec2.IpAddresses.cidr
        :param ip_protocol: The protocol of the vpc. Options are IPv4 only or dual stack. Default: IpProtocol.IPV4_ONLY
        :param ipv6_addresses: The Provider to use to allocate IPv6 Space to your VPC. Options include amazon provided CIDR block. Note this is specific to IPv6 addresses. Default: Ipv6Addresses.amazonProvided
        :param max_azs: Define the maximum number of AZs to use in this region. If the region has more AZs than you want to use (for example, because of EIP limits), pick a lower number here. The AZs will be sorted and picked from the start of the list. If you pick a higher number than the number of AZs in the region, all AZs in the region will be selected. To use "all AZs" available to your account, use a high number (such as 99). Be aware that environment-agnostic stacks will be created with access to only 2 AZs, so to use more than 2 AZs, be sure to specify the account and region on your stack. Specify this option only if you do not specify ``availabilityZones``. Default: 3
        :param nat_gateway_provider: What type of NAT provider to use. Select between NAT gateways or NAT instances. NAT gateways may not be available in all AWS regions. Default: NatProvider.gateway()
        :param nat_gateways: The number of NAT Gateways/Instances to create. The type of NAT gateway or instance will be determined by the ``natGatewayProvider`` parameter. You can set this number lower than the number of Availability Zones in your VPC in order to save on NAT cost. Be aware you may be charged for cross-AZ data traffic instead. Default: - One NAT gateway/instance per Availability Zone
        :param nat_gateway_subnets: Configures the subnets which will have NAT Gateways/Instances. You can pick a specific group of subnets by specifying the group name; the picked subnets must be public subnets. Only necessary if you have more than one public subnet group. Default: - All public subnets.
        :param reserved_azs: Define the number of AZs to reserve. When specified, the IP space is reserved for the azs but no actual resources are provisioned. Default: 0
        :param restrict_default_security_group: If set to true then the default inbound & outbound rules will be removed from the default security group. Default: true if '@aws-cdk/aws-ec2:restrictDefaultSecurityGroup' is enabled, false otherwise
        :param subnet_configuration: Configure the subnets to build for each AZ. Each entry in this list configures a Subnet Group; each group will contain a subnet for each Availability Zone. For example, if you want 1 public subnet, 1 private subnet, and 1 isolated subnet in each AZ provide the following:: new ec2.Vpc(this, 'VPC', { subnetConfiguration: [ { cidrMask: 24, name: 'ingress', subnetType: ec2.SubnetType.PUBLIC, }, { cidrMask: 24, name: 'application', subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS, }, { cidrMask: 28, name: 'rds', subnetType: ec2.SubnetType.PRIVATE_ISOLATED, } ] }); Default: - The VPC CIDR will be evenly divided between 1 public and 1 private subnet per AZ.
        :param vpc_name: The VPC name. Since the VPC resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag Default: this.node.path
        :param vpn_connections: VPN connections to this VPC. Default: - No connections.
        :param vpn_gateway: Indicates whether a VPN gateway should be created and attached to this VPC. Default: - true when vpnGatewayAsn or vpnConnections is specified
        :param vpn_gateway_asn: The private Autonomous System Number (ASN) for the VPN gateway. Default: - Amazon default ASN.
        :param vpn_route_propagation: Where to propagate VPN routes. Default: - On the route tables associated with private subnets. If no private subnets exists, isolated subnets are used. If no isolated subnets exists, public subnets are used.

        :exampleMetadata: infused

        Example::

            import aws_cdk.aws_ec2 as ec2
            
            
            vpc = ec2.Vpc(self, "Vpc",
                ip_addresses=ec2.IpAddresses.cidr("10.0.0.0/16")
            )
            
            vpc_connector = apprunner.VpcConnector(self, "VpcConnector",
                vpc=vpc,
                vpc_subnets=vpc.select_subnets(subnet_type=ec2.SubnetType.PUBLIC),
                vpc_connector_name="MyVpcConnector"
            )
            
            apprunner.Service(self, "Service",
                source=apprunner.Source.from_ecr_public(
                    image_configuration=apprunner.ImageConfiguration(port=8000),
                    image_identifier="public.ecr.aws/aws-containers/hello-app-runner:latest"
                ),
                vpc_connector=vpc_connector
            )
        '''
        if isinstance(nat_gateway_subnets, dict):
            nat_gateway_subnets = SubnetSelection(**nat_gateway_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3cb5105a8b030f970c4d6ccbbc9c8fc7561e1c1fdb31be72509804a81d8a6d11)
            check_type(argname="argument availability_zones", value=availability_zones, expected_type=type_hints["availability_zones"])
            check_type(argname="argument cidr", value=cidr, expected_type=type_hints["cidr"])
            check_type(argname="argument create_internet_gateway", value=create_internet_gateway, expected_type=type_hints["create_internet_gateway"])
            check_type(argname="argument default_instance_tenancy", value=default_instance_tenancy, expected_type=type_hints["default_instance_tenancy"])
            check_type(argname="argument enable_dns_hostnames", value=enable_dns_hostnames, expected_type=type_hints["enable_dns_hostnames"])
            check_type(argname="argument enable_dns_support", value=enable_dns_support, expected_type=type_hints["enable_dns_support"])
            check_type(argname="argument flow_logs", value=flow_logs, expected_type=type_hints["flow_logs"])
            check_type(argname="argument gateway_endpoints", value=gateway_endpoints, expected_type=type_hints["gateway_endpoints"])
            check_type(argname="argument ip_addresses", value=ip_addresses, expected_type=type_hints["ip_addresses"])
            check_type(argname="argument ip_protocol", value=ip_protocol, expected_type=type_hints["ip_protocol"])
            check_type(argname="argument ipv6_addresses", value=ipv6_addresses, expected_type=type_hints["ipv6_addresses"])
            check_type(argname="argument max_azs", value=max_azs, expected_type=type_hints["max_azs"])
            check_type(argname="argument nat_gateway_provider", value=nat_gateway_provider, expected_type=type_hints["nat_gateway_provider"])
            check_type(argname="argument nat_gateways", value=nat_gateways, expected_type=type_hints["nat_gateways"])
            check_type(argname="argument nat_gateway_subnets", value=nat_gateway_subnets, expected_type=type_hints["nat_gateway_subnets"])
            check_type(argname="argument reserved_azs", value=reserved_azs, expected_type=type_hints["reserved_azs"])
            check_type(argname="argument restrict_default_security_group", value=restrict_default_security_group, expected_type=type_hints["restrict_default_security_group"])
            check_type(argname="argument subnet_configuration", value=subnet_configuration, expected_type=type_hints["subnet_configuration"])
            check_type(argname="argument vpc_name", value=vpc_name, expected_type=type_hints["vpc_name"])
            check_type(argname="argument vpn_connections", value=vpn_connections, expected_type=type_hints["vpn_connections"])
            check_type(argname="argument vpn_gateway", value=vpn_gateway, expected_type=type_hints["vpn_gateway"])
            check_type(argname="argument vpn_gateway_asn", value=vpn_gateway_asn, expected_type=type_hints["vpn_gateway_asn"])
            check_type(argname="argument vpn_route_propagation", value=vpn_route_propagation, expected_type=type_hints["vpn_route_propagation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if availability_zones is not None:
            self._values["availability_zones"] = availability_zones
        if cidr is not None:
            self._values["cidr"] = cidr
        if create_internet_gateway is not None:
            self._values["create_internet_gateway"] = create_internet_gateway
        if default_instance_tenancy is not None:
            self._values["default_instance_tenancy"] = default_instance_tenancy
        if enable_dns_hostnames is not None:
            self._values["enable_dns_hostnames"] = enable_dns_hostnames
        if enable_dns_support is not None:
            self._values["enable_dns_support"] = enable_dns_support
        if flow_logs is not None:
            self._values["flow_logs"] = flow_logs
        if gateway_endpoints is not None:
            self._values["gateway_endpoints"] = gateway_endpoints
        if ip_addresses is not None:
            self._values["ip_addresses"] = ip_addresses
        if ip_protocol is not None:
            self._values["ip_protocol"] = ip_protocol
        if ipv6_addresses is not None:
            self._values["ipv6_addresses"] = ipv6_addresses
        if max_azs is not None:
            self._values["max_azs"] = max_azs
        if nat_gateway_provider is not None:
            self._values["nat_gateway_provider"] = nat_gateway_provider
        if nat_gateways is not None:
            self._values["nat_gateways"] = nat_gateways
        if nat_gateway_subnets is not None:
            self._values["nat_gateway_subnets"] = nat_gateway_subnets
        if reserved_azs is not None:
            self._values["reserved_azs"] = reserved_azs
        if restrict_default_security_group is not None:
            self._values["restrict_default_security_group"] = restrict_default_security_group
        if subnet_configuration is not None:
            self._values["subnet_configuration"] = subnet_configuration
        if vpc_name is not None:
            self._values["vpc_name"] = vpc_name
        if vpn_connections is not None:
            self._values["vpn_connections"] = vpn_connections
        if vpn_gateway is not None:
            self._values["vpn_gateway"] = vpn_gateway
        if vpn_gateway_asn is not None:
            self._values["vpn_gateway_asn"] = vpn_gateway_asn
        if vpn_route_propagation is not None:
            self._values["vpn_route_propagation"] = vpn_route_propagation

    @builtins.property
    def availability_zones(self) -> typing.Optional[typing.List[builtins.str]]:
        '''Availability zones this VPC spans.

        Specify this option only if you do not specify ``maxAzs``.

        :default: - a subset of AZs of the stack
        '''
        result = self._values.get("availability_zones")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def cidr(self) -> typing.Optional[builtins.str]:
        '''(deprecated) The CIDR range to use for the VPC, e.g. '10.0.0.0/16'.

        Should be a minimum of /28 and maximum size of /16. The range will be
        split across all subnets per Availability Zone.

        :default: Vpc.DEFAULT_CIDR_RANGE

        :deprecated: Use ipAddresses instead

        :stability: deprecated
        '''
        result = self._values.get("cidr")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def create_internet_gateway(self) -> typing.Optional[builtins.bool]:
        '''If set to false then disable the creation of the default internet gateway.

        :default: true
        '''
        result = self._values.get("create_internet_gateway")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def default_instance_tenancy(self) -> typing.Optional[DefaultInstanceTenancy]:
        '''The default tenancy of instances launched into the VPC.

        By setting this to dedicated tenancy, instances will be launched on
        hardware dedicated to a single AWS customer, unless specifically specified
        at instance launch time. Please note, not all instance types are usable
        with Dedicated tenancy.

        :default: DefaultInstanceTenancy.Default (shared) tenancy
        '''
        result = self._values.get("default_instance_tenancy")
        return typing.cast(typing.Optional[DefaultInstanceTenancy], result)

    @builtins.property
    def enable_dns_hostnames(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether the instances launched in the VPC get public DNS hostnames.

        If this attribute is true, instances in the VPC get public DNS hostnames,
        but only if the enableDnsSupport attribute is also set to true.

        :default: true
        '''
        result = self._values.get("enable_dns_hostnames")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def enable_dns_support(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether the DNS resolution is supported for the VPC.

        If this attribute is false, the Amazon-provided DNS server in the VPC that
        resolves public DNS hostnames to IP addresses is not enabled. If this
        attribute is true, queries to the Amazon provided DNS server at the
        169.254.169.253 IP address, or the reserved IP address at the base of the
        VPC IPv4 network range plus two will succeed.

        :default: true
        '''
        result = self._values.get("enable_dns_support")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def flow_logs(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, FlowLogOptions]]:
        '''Flow logs to add to this VPC.

        :default: - No flow logs.
        '''
        result = self._values.get("flow_logs")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, FlowLogOptions]], result)

    @builtins.property
    def gateway_endpoints(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, GatewayVpcEndpointOptions]]:
        '''Gateway endpoints to add to this VPC.

        :default: - None.
        '''
        result = self._values.get("gateway_endpoints")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, GatewayVpcEndpointOptions]], result)

    @builtins.property
    def ip_addresses(self) -> typing.Optional[IIpAddresses]:
        '''The Provider to use to allocate IPv4 Space to your VPC.

        Options include static allocation or from a pool.

        Note this is specific to IPv4 addresses.

        :default: ec2.IpAddresses.cidr
        '''
        result = self._values.get("ip_addresses")
        return typing.cast(typing.Optional[IIpAddresses], result)

    @builtins.property
    def ip_protocol(self) -> typing.Optional[IpProtocol]:
        '''The protocol of the vpc.

        Options are IPv4 only or dual stack.

        :default: IpProtocol.IPV4_ONLY
        '''
        result = self._values.get("ip_protocol")
        return typing.cast(typing.Optional[IpProtocol], result)

    @builtins.property
    def ipv6_addresses(self) -> typing.Optional[IIpv6Addresses]:
        '''The Provider to use to allocate IPv6 Space to your VPC.

        Options include amazon provided CIDR block.

        Note this is specific to IPv6 addresses.

        :default: Ipv6Addresses.amazonProvided
        '''
        result = self._values.get("ipv6_addresses")
        return typing.cast(typing.Optional[IIpv6Addresses], result)

    @builtins.property
    def max_azs(self) -> typing.Optional[jsii.Number]:
        '''Define the maximum number of AZs to use in this region.

        If the region has more AZs than you want to use (for example, because of
        EIP limits), pick a lower number here. The AZs will be sorted and picked
        from the start of the list.

        If you pick a higher number than the number of AZs in the region, all AZs
        in the region will be selected. To use "all AZs" available to your
        account, use a high number (such as 99).

        Be aware that environment-agnostic stacks will be created with access to
        only 2 AZs, so to use more than 2 AZs, be sure to specify the account and
        region on your stack.

        Specify this option only if you do not specify ``availabilityZones``.

        :default: 3
        '''
        result = self._values.get("max_azs")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def nat_gateway_provider(self) -> typing.Optional[NatProvider]:
        '''What type of NAT provider to use.

        Select between NAT gateways or NAT instances. NAT gateways
        may not be available in all AWS regions.

        :default: NatProvider.gateway()
        '''
        result = self._values.get("nat_gateway_provider")
        return typing.cast(typing.Optional[NatProvider], result)

    @builtins.property
    def nat_gateways(self) -> typing.Optional[jsii.Number]:
        '''The number of NAT Gateways/Instances to create.

        The type of NAT gateway or instance will be determined by the
        ``natGatewayProvider`` parameter.

        You can set this number lower than the number of Availability Zones in your
        VPC in order to save on NAT cost. Be aware you may be charged for
        cross-AZ data traffic instead.

        :default: - One NAT gateway/instance per Availability Zone
        '''
        result = self._values.get("nat_gateways")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def nat_gateway_subnets(self) -> typing.Optional[SubnetSelection]:
        '''Configures the subnets which will have NAT Gateways/Instances.

        You can pick a specific group of subnets by specifying the group name;
        the picked subnets must be public subnets.

        Only necessary if you have more than one public subnet group.

        :default: - All public subnets.
        '''
        result = self._values.get("nat_gateway_subnets")
        return typing.cast(typing.Optional[SubnetSelection], result)

    @builtins.property
    def reserved_azs(self) -> typing.Optional[jsii.Number]:
        '''Define the number of AZs to reserve.

        When specified, the IP space is reserved for the azs but no actual
        resources are provisioned.

        :default: 0
        '''
        result = self._values.get("reserved_azs")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def restrict_default_security_group(self) -> typing.Optional[builtins.bool]:
        '''If set to true then the default inbound & outbound rules will be removed from the default security group.

        :default: true if '@aws-cdk/aws-ec2:restrictDefaultSecurityGroup' is enabled, false otherwise
        '''
        result = self._values.get("restrict_default_security_group")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subnet_configuration(self) -> typing.Optional[typing.List[SubnetConfiguration]]:
        '''Configure the subnets to build for each AZ.

        Each entry in this list configures a Subnet Group; each group will contain a
        subnet for each Availability Zone.

        For example, if you want 1 public subnet, 1 private subnet, and 1 isolated
        subnet in each AZ provide the following::

           ec2.Vpc(self, "VPC",
               subnet_configuration=[ec2.SubnetConfiguration(
                   cidr_mask=24,
                   name="ingress",
                   subnet_type=ec2.SubnetType.PUBLIC
               ), ec2.SubnetConfiguration(
                   cidr_mask=24,
                   name="application",
                   subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS
               ), ec2.SubnetConfiguration(
                   cidr_mask=28,
                   name="rds",
                   subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
               )
               ]
           )

        :default:

        - The VPC CIDR will be evenly divided between 1 public and 1
        private subnet per AZ.
        '''
        result = self._values.get("subnet_configuration")
        return typing.cast(typing.Optional[typing.List[SubnetConfiguration]], result)

    @builtins.property
    def vpc_name(self) -> typing.Optional[builtins.str]:
        '''The VPC name.

        Since the VPC resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag

        :default: this.node.path
        '''
        result = self._values.get("vpc_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vpn_connections(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "VpnConnectionOptions"]]:
        '''VPN connections to this VPC.

        :default: - No connections.
        '''
        result = self._values.get("vpn_connections")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "VpnConnectionOptions"]], result)

    @builtins.property
    def vpn_gateway(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether a VPN gateway should be created and attached to this VPC.

        :default: - true when vpnGatewayAsn or vpnConnections is specified
        '''
        result = self._values.get("vpn_gateway")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def vpn_gateway_asn(self) -> typing.Optional[jsii.Number]:
        '''The private Autonomous System Number (ASN) for the VPN gateway.

        :default: - Amazon default ASN.
        '''
        result = self._values.get("vpn_gateway_asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def vpn_route_propagation(self) -> typing.Optional[typing.List[SubnetSelection]]:
        '''Where to propagate VPN routes.

        :default:

        - On the route tables associated with private subnets. If no
        private subnets exists, isolated subnets are used. If no isolated subnets
        exists, public subnets are used.
        '''
        result = self._values.get("vpn_route_propagation")
        return typing.cast(typing.Optional[typing.List[SubnetSelection]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpcProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpnConnectionAttributes",
    jsii_struct_bases=[],
    name_mapping={
        "customer_gateway_asn": "customerGatewayAsn",
        "customer_gateway_id": "customerGatewayId",
        "customer_gateway_ip": "customerGatewayIp",
        "vpn_id": "vpnId",
    },
)
class VpnConnectionAttributes:
    def __init__(
        self,
        *,
        customer_gateway_asn: jsii.Number,
        customer_gateway_id: builtins.str,
        customer_gateway_ip: builtins.str,
        vpn_id: builtins.str,
    ) -> None:
        '''Attributes of an imported VpnConnection.

        :param customer_gateway_asn: The ASN of the customer gateway.
        :param customer_gateway_id: The id of the customer gateway.
        :param customer_gateway_ip: The ip address of the customer gateway.
        :param vpn_id: The id of the VPN connection.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            vpn_connection_attributes = ec2.VpnConnectionAttributes(
                customer_gateway_asn=123,
                customer_gateway_id="customerGatewayId",
                customer_gateway_ip="customerGatewayIp",
                vpn_id="vpnId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a901437f27151deb06807ec8a485713c3fcb77d34b4f69a06060baa85e6b178)
            check_type(argname="argument customer_gateway_asn", value=customer_gateway_asn, expected_type=type_hints["customer_gateway_asn"])
            check_type(argname="argument customer_gateway_id", value=customer_gateway_id, expected_type=type_hints["customer_gateway_id"])
            check_type(argname="argument customer_gateway_ip", value=customer_gateway_ip, expected_type=type_hints["customer_gateway_ip"])
            check_type(argname="argument vpn_id", value=vpn_id, expected_type=type_hints["vpn_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "customer_gateway_asn": customer_gateway_asn,
            "customer_gateway_id": customer_gateway_id,
            "customer_gateway_ip": customer_gateway_ip,
            "vpn_id": vpn_id,
        }

    @builtins.property
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        result = self._values.get("customer_gateway_asn")
        assert result is not None, "Required property 'customer_gateway_asn' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        result = self._values.get("customer_gateway_id")
        assert result is not None, "Required property 'customer_gateway_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        result = self._values.get("customer_gateway_ip")
        assert result is not None, "Required property 'customer_gateway_ip' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.'''
        result = self._values.get("vpn_id")
        assert result is not None, "Required property 'vpn_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpnConnectionAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IVpnConnection)
class VpnConnectionBase(
    _Resource_45bc6135,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.VpnConnectionBase",
):
    '''Base class for Vpn connections.'''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        environment_from_arn: typing.Optional[builtins.str] = None,
        physical_name: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param account: The AWS account ID this resource belongs to. Default: - the resource is in the same account as the stack it belongs to
        :param environment_from_arn: ARN to deduce region and account from. The ARN is parsed and the account and region are taken from the ARN. This should be used for imported resources. Cannot be supplied together with either ``account`` or ``region``. Default: - take environment from ``account``, ``region`` parameters, or use Stack environment.
        :param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated by CloudFormation during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation. Default: - The physical name will be allocated by CloudFormation at deployment time
        :param region: The AWS region this resource belongs to. Default: - the resource is in the same region as the stack it belongs to
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__505d7879dbe9a9268db93b27df2b4b2fe2d7041de89f41a6ed28efe88e72bbe7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = _ResourceProps_15a65b4e(
            account=account,
            environment_from_arn=environment_from_arn,
            physical_name=physical_name,
            region=region,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="metric")
    def metric(
        self,
        metric_name: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Return the given named metric for this VPNConnection.

        :param metric_name: -
        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1f244e2fd0db7fcc2c7468799c9a19c8b2a0a6f87bbe53904f9e9cf45c6d5c89)
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metric", [metric_name, props]))

    @jsii.member(jsii_name="metricTunnelDataIn")
    def metric_tunnel_data_in(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes received through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelDataIn", [props]))

    @jsii.member(jsii_name="metricTunnelDataOut")
    def metric_tunnel_data_out(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The bytes sent through the VPN tunnel.

        Sum over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelDataOut", [props]))

    @jsii.member(jsii_name="metricTunnelState")
    def metric_tunnel_state(
        self,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''The state of the tunnel. 0 indicates DOWN and 1 indicates UP.

        Average over 5 minutes

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.invoke(self, "metricTunnelState", [props]))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayAsn")
    @abc.abstractmethod
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    @abc.abstractmethod
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="customerGatewayIp")
    @abc.abstractmethod
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="vpnId")
    @abc.abstractmethod
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.'''
        ...


class _VpnConnectionBaseProxy(
    VpnConnectionBase,
    jsii.proxy_for(_Resource_45bc6135), # type: ignore[misc]
):
    @builtins.property
    @jsii.member(jsii_name="customerGatewayAsn")
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        return typing.cast(jsii.Number, jsii.get(self, "customerGatewayAsn"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayIp")
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayIp"))

    @builtins.property
    @jsii.member(jsii_name="vpnId")
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.'''
        return typing.cast(builtins.str, jsii.get(self, "vpnId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, VpnConnectionBase).__jsii_proxy_class__ = lambda : _VpnConnectionBaseProxy


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpnConnectionOptions",
    jsii_struct_bases=[],
    name_mapping={
        "ip": "ip",
        "asn": "asn",
        "static_routes": "staticRoutes",
        "tunnel_options": "tunnelOptions",
    },
)
class VpnConnectionOptions:
    def __init__(
        self,
        *,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union["VpnTunnelOption", typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options

        :exampleMetadata: fixture=with-vpc infused

        Example::

            # Across all tunnels in the account/region
            all_data_out = ec2.VpnConnection.metric_all_tunnel_data_out()
            
            # For a specific vpn connection
            vpn_connection = vpc.add_vpn_connection("Dynamic",
                ip="1.2.3.4"
            )
            state = vpn_connection.metric_tunnel_state()
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ff732227dca01f55f135b6bdb24565135067d5dad83456915cda99ffe9a2f9be)
            check_type(argname="argument ip", value=ip, expected_type=type_hints["ip"])
            check_type(argname="argument asn", value=asn, expected_type=type_hints["asn"])
            check_type(argname="argument static_routes", value=static_routes, expected_type=type_hints["static_routes"])
            check_type(argname="argument tunnel_options", value=tunnel_options, expected_type=type_hints["tunnel_options"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ip": ip,
        }
        if asn is not None:
            self._values["asn"] = asn
        if static_routes is not None:
            self._values["static_routes"] = static_routes
        if tunnel_options is not None:
            self._values["tunnel_options"] = tunnel_options

    @builtins.property
    def ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        result = self._values.get("ip")
        assert result is not None, "Required property 'ip' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def asn(self) -> typing.Optional[jsii.Number]:
        '''The ASN of the customer gateway.

        :default: 65000
        '''
        result = self._values.get("asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def static_routes(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The static routes to be routed from the VPN gateway to the customer gateway.

        :default: Dynamic routing (BGP)
        '''
        result = self._values.get("static_routes")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tunnel_options(self) -> typing.Optional[typing.List["VpnTunnelOption"]]:
        '''The tunnel options for the VPN connection.

        At most two elements (one per tunnel).
        Duplicates not allowed.

        :default: Amazon generated tunnel options
        '''
        result = self._values.get("tunnel_options")
        return typing.cast(typing.Optional[typing.List["VpnTunnelOption"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpnConnectionOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpnConnectionProps",
    jsii_struct_bases=[VpnConnectionOptions],
    name_mapping={
        "ip": "ip",
        "asn": "asn",
        "static_routes": "staticRoutes",
        "tunnel_options": "tunnelOptions",
        "vpc": "vpc",
    },
)
class VpnConnectionProps(VpnConnectionOptions):
    def __init__(
        self,
        *,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union["VpnTunnelOption", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc: IVpc,
    ) -> None:
        '''
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options
        :param vpc: The VPC to connect to.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            
            # secret_value: cdk.SecretValue
            # vpc: ec2.Vpc
            
            vpn_connection_props = ec2.VpnConnectionProps(
                ip="ip",
                vpc=vpc,
            
                # the properties below are optional
                asn=123,
                static_routes=["staticRoutes"],
                tunnel_options=[ec2.VpnTunnelOption(
                    pre_shared_key="preSharedKey",
                    pre_shared_key_secret=secret_value,
                    tunnel_inside_cidr="tunnelInsideCidr"
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8e449d38bf29da9472a911313d5f309a2388d3415c663cf37ec0fe34e62f8909)
            check_type(argname="argument ip", value=ip, expected_type=type_hints["ip"])
            check_type(argname="argument asn", value=asn, expected_type=type_hints["asn"])
            check_type(argname="argument static_routes", value=static_routes, expected_type=type_hints["static_routes"])
            check_type(argname="argument tunnel_options", value=tunnel_options, expected_type=type_hints["tunnel_options"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "ip": ip,
            "vpc": vpc,
        }
        if asn is not None:
            self._values["asn"] = asn
        if static_routes is not None:
            self._values["static_routes"] = static_routes
        if tunnel_options is not None:
            self._values["tunnel_options"] = tunnel_options

    @builtins.property
    def ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        result = self._values.get("ip")
        assert result is not None, "Required property 'ip' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def asn(self) -> typing.Optional[jsii.Number]:
        '''The ASN of the customer gateway.

        :default: 65000
        '''
        result = self._values.get("asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def static_routes(self) -> typing.Optional[typing.List[builtins.str]]:
        '''The static routes to be routed from the VPN gateway to the customer gateway.

        :default: Dynamic routing (BGP)
        '''
        result = self._values.get("static_routes")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def tunnel_options(self) -> typing.Optional[typing.List["VpnTunnelOption"]]:
        '''The tunnel options for the VPN connection.

        At most two elements (one per tunnel).
        Duplicates not allowed.

        :default: Amazon generated tunnel options
        '''
        result = self._values.get("tunnel_options")
        return typing.cast(typing.Optional[typing.List["VpnTunnelOption"]], result)

    @builtins.property
    def vpc(self) -> IVpc:
        '''The VPC to connect to.'''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast(IVpc, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpnConnectionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.VpnConnectionType")
class VpnConnectionType(enum.Enum):
    '''The VPN connection type.'''

    IPSEC_1 = "IPSEC_1"
    '''The IPsec 1 VPN connection type.'''
    DUMMY = "DUMMY"
    '''Dummy member TODO: remove once https://github.com/aws/jsii/issues/231 is fixed.'''


@jsii.implements(IVpnGateway)
class VpnGateway(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.VpnGateway",
):
    '''The VPN Gateway that shall be added to the VPC.

    :resource: AWS::EC2::VPNGateway
    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        vpn_gateway = ec2.VpnGateway(self, "MyVpnGateway",
            type="type",
        
            # the properties below are optional
            amazon_side_asn=123
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed82ed51aff7000fad288fdd2f04f94c59571252b6810c17b6528b50d626484c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = VpnGatewayProps(type=type, amazon_side_asn=amazon_side_asn)

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="gatewayId")
    def gateway_id(self) -> builtins.str:
        '''The virtual private gateway Id.'''
        return typing.cast(builtins.str, jsii.get(self, "gatewayId"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpnGatewayProps",
    jsii_struct_bases=[],
    name_mapping={"type": "type", "amazon_side_asn": "amazonSideAsn"},
)
class VpnGatewayProps:
    def __init__(
        self,
        *,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''The VpnGateway Properties.

        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            vpn_gateway_props = ec2.VpnGatewayProps(
                type="type",
            
                # the properties below are optional
                amazon_side_asn=123
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a626cf8aa20d225a5f0ad2fa027f8c61d183d4e21b0bc1374f5de30f67b20b70)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument amazon_side_asn", value=amazon_side_asn, expected_type=type_hints["amazon_side_asn"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
        }
        if amazon_side_asn is not None:
            self._values["amazon_side_asn"] = amazon_side_asn

    @builtins.property
    def type(self) -> builtins.str:
        '''Default type ipsec.1.'''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''Explicitly specify an Asn or let aws pick an Asn for you.

        :default: 65000
        '''
        result = self._values.get("amazon_side_asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpnGatewayProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.VpnPort")
class VpnPort(enum.Enum):
    '''Port for client VPN.'''

    HTTPS = "HTTPS"
    '''HTTPS.'''
    OPENVPN = "OPENVPN"
    '''OpenVPN.'''


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.VpnTunnelOption",
    jsii_struct_bases=[],
    name_mapping={
        "pre_shared_key": "preSharedKey",
        "pre_shared_key_secret": "preSharedKeySecret",
        "tunnel_inside_cidr": "tunnelInsideCidr",
    },
)
class VpnTunnelOption:
    def __init__(
        self,
        *,
        pre_shared_key: typing.Optional[builtins.str] = None,
        pre_shared_key_secret: typing.Optional[_SecretValue_3dd0ddae] = None,
        tunnel_inside_cidr: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param pre_shared_key: (deprecated) The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway. Allowed characters are alphanumeric characters period ``.`` and underscores ``_``. Must be between 8 and 64 characters in length and cannot start with zero (0). Default: an Amazon generated pre-shared key
        :param pre_shared_key_secret: The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway. Allowed characters are alphanumeric characters period ``.`` and underscores ``_``. Must be between 8 and 64 characters in length and cannot start with zero (0). Default: an Amazon generated pre-shared key
        :param tunnel_inside_cidr: The range of inside IP addresses for the tunnel. Any specified CIDR blocks must be unique across all VPN connections that use the same virtual private gateway. A size /30 CIDR block from the 169.254.0.0/16 range. Default: an Amazon generated inside IP CIDR

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            
            # secret_value: cdk.SecretValue
            
            vpn_tunnel_option = ec2.VpnTunnelOption(
                pre_shared_key="preSharedKey",
                pre_shared_key_secret=secret_value,
                tunnel_inside_cidr="tunnelInsideCidr"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__772a1fa12499f7302933a4967cff0b4e29e035402dda70c99e43af2ae184c046)
            check_type(argname="argument pre_shared_key", value=pre_shared_key, expected_type=type_hints["pre_shared_key"])
            check_type(argname="argument pre_shared_key_secret", value=pre_shared_key_secret, expected_type=type_hints["pre_shared_key_secret"])
            check_type(argname="argument tunnel_inside_cidr", value=tunnel_inside_cidr, expected_type=type_hints["tunnel_inside_cidr"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if pre_shared_key is not None:
            self._values["pre_shared_key"] = pre_shared_key
        if pre_shared_key_secret is not None:
            self._values["pre_shared_key_secret"] = pre_shared_key_secret
        if tunnel_inside_cidr is not None:
            self._values["tunnel_inside_cidr"] = tunnel_inside_cidr

    @builtins.property
    def pre_shared_key(self) -> typing.Optional[builtins.str]:
        '''(deprecated) The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway.

        Allowed characters are
        alphanumeric characters period ``.`` and underscores ``_``. Must be between 8
        and 64 characters in length and cannot start with zero (0).

        :default: an Amazon generated pre-shared key

        :deprecated: Use ``preSharedKeySecret`` instead

        :stability: deprecated
        '''
        result = self._values.get("pre_shared_key")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def pre_shared_key_secret(self) -> typing.Optional[_SecretValue_3dd0ddae]:
        '''The pre-shared key (PSK) to establish initial authentication between the virtual private gateway and customer gateway.

        Allowed characters are
        alphanumeric characters period ``.`` and underscores ``_``. Must be between 8
        and 64 characters in length and cannot start with zero (0).

        :default: an Amazon generated pre-shared key
        '''
        result = self._values.get("pre_shared_key_secret")
        return typing.cast(typing.Optional[_SecretValue_3dd0ddae], result)

    @builtins.property
    def tunnel_inside_cidr(self) -> typing.Optional[builtins.str]:
        '''The range of inside IP addresses for the tunnel.

        Any specified CIDR blocks must be
        unique across all VPN connections that use the same virtual private gateway.
        A size /30 CIDR block from the 169.254.0.0/16 range.

        :default: an Amazon generated inside IP CIDR
        '''
        result = self._values.get("tunnel_inside_cidr")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VpnTunnelOption(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.WindowsImageProps",
    jsii_struct_bases=[],
    name_mapping={"user_data": "userData"},
)
class WindowsImageProps:
    def __init__(self, *, user_data: typing.Optional[UserData] = None) -> None:
        '''Configuration options for WindowsImage.

        :param user_data: Initial user data. Default: - Empty UserData for Windows machines

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # user_data: ec2.UserData
            
            windows_image_props = ec2.WindowsImageProps(
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4e19c68e3e7dc3f6551ac414ee3fbb705ea736ea29d1862d436b09746cce7935)
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if user_data is not None:
            self._values["user_data"] = user_data

    @builtins.property
    def user_data(self) -> typing.Optional[UserData]:
        '''Initial user data.

        :default: - Empty UserData for Windows machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional[UserData], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "WindowsImageProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.WindowsUserDataOptions",
    jsii_struct_bases=[],
    name_mapping={"persist": "persist"},
)
class WindowsUserDataOptions:
    def __init__(self, *, persist: typing.Optional[builtins.bool] = None) -> None:
        '''Options when constructing UserData for Windows.

        :param persist: Set to true to set this userdata to persist through an instance reboot; allowing it to run on every instance start. By default, UserData is run only once during the first instance launch. For more information, see: https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/ https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-windows-user-data.html#user-data-scripts Default: false

        :exampleMetadata: infused

        Example::

            windows_user_data = ec2.UserData.for_windows(persist=True)
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a9243d0fea7f4d4e8b65c37925a1dbb71b6136866e6c28c37f9d5dc79df4716d)
            check_type(argname="argument persist", value=persist, expected_type=type_hints["persist"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if persist is not None:
            self._values["persist"] = persist

    @builtins.property
    def persist(self) -> typing.Optional[builtins.bool]:
        '''Set to true to set this userdata to persist through an instance reboot;

        allowing
        it to run on every instance start.
        By default, UserData is run only once during the first instance launch.

        For more information, see:
        https://aws.amazon.com/premiumsupport/knowledge-center/execute-user-data-ec2/
        https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2-windows-user-data.html#user-data-scripts

        :default: false
        '''
        result = self._values.get("persist")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "WindowsUserDataOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="aws-cdk-lib.aws_ec2.WindowsVersion")
class WindowsVersion(enum.Enum):
    '''The Windows version to use for the WindowsImage.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_22 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_22"
    '''EKS Optimized - Start.'''
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_22 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_22"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_23 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_23"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_23 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_23"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_24 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_24"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_24 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_24"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_25 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_25"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_25 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_25"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_26 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_26"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_26 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_26"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_27 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_27"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_27 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_27"
    WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_28 = "WINDOWS_SERVER_2019_ENGLISH_CORE_EKS_OPTIMIZED_1_28"
    WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_28 = "WINDOWS_SERVER_2019_ENGLISH_FULL_EKS_OPTIMIZED_1_28"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_23 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_23"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_23 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_23"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_24 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_24"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_24 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_24"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_25 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_25"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_25 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_25"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_26 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_26"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_26 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_26"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_27 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_27"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_27 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_27"
    WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_28 = "WINDOWS_SERVER_2022_ENGLISH_CORE_EKS_OPTIMIZED_1_28"
    WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_28 = "WINDOWS_SERVER_2022_ENGLISH_FULL_EKS_OPTIMIZED_1_28"
    WINDOWS_SERVER_1709_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_1709_ENGLISH_CORE_CONTAINERSLATEST"
    '''1709 - Start.'''
    WINDOWS_SERVER_1709_ENGLISH_CORE_BASE = "WINDOWS_SERVER_1709_ENGLISH_CORE_BASE"
    WINDOWS_SERVER_1803_ENGLISH_CORE_BASE = "WINDOWS_SERVER_1803_ENGLISH_CORE_BASE"
    '''1803 - Start.'''
    WINDOWS_SERVER_1803_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_1803_ENGLISH_CORE_CONTAINERSLATEST"
    WINDOWS_SERVER_1809_ENGLISH_CORE_BASE = "WINDOWS_SERVER_1809_ENGLISH_CORE_BASE"
    '''1809 - Start.'''
    WINDOWS_SERVER_1809_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_1809_ENGLISH_CORE_CONTAINERSLATEST"
    WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_32BIT_BASE = "WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_32BIT_BASE"
    '''2003 - Start.'''
    WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_SQL_2005_SP4_EXPRESS = "WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_SQL_2005_SP4_EXPRESS"
    WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_SQL_2005_SP4_STANDARD = "WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_SQL_2005_SP4_STANDARD"
    WINDOWS_SERVER_2003_R2_SP2_ENGLISH_32BIT_BASE = "WINDOWS_SERVER_2003_R2_SP2_ENGLISH_32BIT_BASE"
    WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_BASE = "WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_BASE"
    WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_SQL_2005_SP4_EXPRESS = "WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_SQL_2005_SP4_EXPRESS"
    WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_SQL_2005_SP4_STANDARD = "WINDOWS_SERVER_2003_R2_SP2_ENGLISH_64BIT_SQL_2005_SP4_STANDARD"
    WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_BASE = "WINDOWS_SERVER_2003_R2_SP2_LANGUAGE_PACKS_64BIT_BASE"
    WINDOWS_SERVER_2007_R2_SP1_LANGUAGE_PACKS_64BIT_BASE = "WINDOWS_SERVER_2007_R2_SP1_LANGUAGE_PACKS_64BIT_BASE"
    '''2007 - Start.'''
    WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_SQL_2008_SP4_EXPRESS = "WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_SQL_2008_SP4_EXPRESS"
    '''2008 - Start.'''
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_WEB = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_WEB"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_EXPRESS = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_EXPRESS"
    WINDOWS_SERVER_2008_R2_SP1_KOREAN_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_KOREAN_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_CHINESE_HONG_KONG_SAR_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_CHINESE_HONG_KONG_SAR_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_CHINESE_PRC_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_CHINESE_PRC_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_EXPRESS = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_EXPRESS"
    WINDOWS_SERVER_2008_SP2_ENGLISH_32BIT_BASE = "WINDOWS_SERVER_2008_SP2_ENGLISH_32BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_WEB = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_WEB"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_BASE"
    WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_SQL_2008_SP4_STANDARD = "WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_SQL_2008_SP4_STANDARD"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2012_SP4_EXPRESS = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2012_SP4_EXPRESS"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_WEB = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_WEB"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2012_SP4_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2012_SP4_STANDARD"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_STANDARD"
    WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_BASE = "WINDOWS_SERVER_2008_SP2_ENGLISH_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE"
    WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_EXPRESS = "WINDOWS_SERVER_2008_R2_SP1_JAPANESE_64BIT_SQL_2008_R2_SP3_EXPRESS"
    WINDOWS_SERVER_2008_R2_SP1_PORTUGUESE_BRAZIL_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_PORTUGUESE_BRAZIL_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_LANGUAGE_PACKS_64BIT_SQL_2008_R2_SP3_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_LANGUAGE_PACKS_64BIT_SQL_2008_R2_SP3_STANDARD"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_61BIT_SQL_2012_RTM_SP2_ENTERPRISE = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_61BIT_SQL_2012_RTM_SP2_ENTERPRISE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2012_SP4_STANDARD"
    WINDOWS_SERVER_2008_SP2_PORTUGUESE_BRAZIL_32BIT_BASE = "WINDOWS_SERVER_2008_SP2_PORTUGUESE_BRAZIL_32BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_BASE = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_BASE"
    WINDOWS_SERVER_2008_R2_SP1_LANGUAGE_PACKS_64BIT_SQL_2008_R2_SP3_EXPRESS = "WINDOWS_SERVER_2008_R2_SP1_LANGUAGE_PACKS_64BIT_SQL_2008_R2_SP3_EXPRESS"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_CORE_SQL_2012_SP4_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_CORE_SQL_2012_SP4_STANDARD"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_CORE = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_CORE"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_STANDARD = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SQL_2008_R2_SP3_STANDARD"
    WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SHAREPOINT_2010_SP2_FOUNDATION = "WINDOWS_SERVER_2008_R2_SP1_ENGLISH_64BIT_SHAREPOINT_2010_SP2_FOUNDATION"
    WINDOWS_SERVER_2012_R2_RTM_CHINESE_SIMPLIFIED_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_CHINESE_SIMPLIFIED_64BIT_BASE"
    '''2012 - Start.'''
    WINDOWS_SERVER_2012_R2_RTM_CHINESE_TRADITIONAL_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_CHINESE_TRADITIONAL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_DUTCH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_DUTCH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_ENTERPRISE"
    WINDOWS_SERVER_2012_R2_RTM_HUNGARIAN_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_HUNGARIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2008_R2_SP3_EXPRESS = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2008_R2_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_SP1_PORTUGUESE_BRAZIL_64BIT_CORE = "WINDOWS_SERVER_2012_R2_SP1_PORTUGUESE_BRAZIL_64BIT_CORE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_EXPRESS = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_EXPRESS"
    WINDOWS_SERVER_2012_RTM_ITALIAN_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_ITALIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_WEB = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_WEB"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_DEEP_LEARNING = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_DEEP_LEARNING"
    WINDOWS_SERVER_2012_R2_RTM_GERMAN_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_GERMAN_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_RUSSIAN_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_RUSSIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_CHINESE_TRADITIONAL_HONG_KONG_SAR_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_CHINESE_TRADITIONAL_HONG_KONG_SAR_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_HUNGARIAN_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_HUNGARIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_STANDARD = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_STANDARD"
    WINDOWS_SERVER_2012_RTM_FRENCH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_FRENCH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_FRENCH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_FRENCH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_POLISH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_POLISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_EXPRESS = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_EXPRESS"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP3_STANDARD = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP3_STANDARD"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_2012_SP4_STANDARD = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_2012_SP4_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_WEB = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_WEB"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_WEB = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_WEB"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_CORE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_CORE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_WEB = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_WEB"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_ENTERPRISE"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_2014_SP3_WEB = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_2014_SP3_WEB"
    WINDOWS_SERVER_2012_RTM_SWEDISH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_SWEDISH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_BRAZIL_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_BRAZIL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_SWEDISH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_SWEDISH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE"
    WINDOWS_SERVER_2012_RTM_CHINESE_TRADITIONAL_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_CHINESE_TRADITIONAL_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_STANDARD = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_STANDARD"
    WINDOWS_SERVER_2012_RTM_CZECH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_CZECH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_TURKISH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_TURKISH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_HYPERV = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_HYPERV"
    WINDOWS_SERVER_2012_RTM_KOREAN_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_KOREAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_RUSSIAN_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_RUSSIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_FULL_BASE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_FULL_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP2_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_ITALIAN_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_ITALIAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2008_R2_SP3_STANDARD = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2008_R2_SP3_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2007_R2_SP3_WEB = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2007_R2_SP3_WEB"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_WEB = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_WEB"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_EXPRESS = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_CZECH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_CZECH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP2_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP2_EXPRESS"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_STANDARD = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_STANDARD"
    WINDOWS_SERVER_2012_SP2_PORTUGUESE_BRAZIL_64BIT_BASE = "WINDOWS_SERVER_2012_SP2_PORTUGUESE_BRAZIL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_WEB = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_WEB"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP3_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP1_ENTERPRISE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP3_EXPRESS = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP3_EXPRESS"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_STANDARD = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP2_STANDARD"
    WINDOWS_SERVER_2012_RTM_ENGLISH_FULL_BASE = "WINDOWS_SERVER_2012_RTM_ENGLISH_FULL_BASE"
    WINDOWS_SERVER_2012_R2_ENGLISH_STIG_FULL = "WINDOWS_SERVER_2012_R2_ENGLISH_STIG_FULL"
    WINDOWS_SERVER_2012_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_PORTUGUESE_PORTUGAL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP1_ENTERPRISE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_WEB = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2014_SP2_WEB"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2008_R2_SP3_EXPRESS = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2008_R2_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_PORTUGUESE_BRAZIL_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_PORTUGUESE_BRAZIL_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_P3 = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_P3"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP3_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP3_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_SPANISH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_SPANISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_EXPRESS = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2012_R2_ENGLISH_STIG_CORE = "WINDOWS_SERVER_2012_R2_ENGLISH_STIG_CORE"
    WINDOWS_SERVER_2012_R2_RTM_TURKISH_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_TURKISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2012_SP4_WEB = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2012_SP4_WEB"
    WINDOWS_SERVER_2012_RTM_POLISH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_POLISH_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_SPANISH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_SPANISH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_WEB = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_WEB"
    WINDOWS_SERVER_2012_R2_RTM_KOREAN_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_KOREAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_DUTCH_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_DUTCH_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_CHINESE_TRADITIONAL_HONG_KONG_64BIT_BASE = "WINDOWS_SERVER_2012_R2_RTM_CHINESE_TRADITIONAL_HONG_KONG_64BIT_BASE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2014_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2012_RTM_CHINESE_SIMPLIFIED_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_CHINESE_SIMPLIFIED_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_WEB = "WINDOWS_SERVER_2012_RTM_ENGLISH_64BIT_SQL_2012_SP4_WEB"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_WEB = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2014_SP3_WEB"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP2_STANDARD = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2014_SP2_STANDARD"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2012_SP4_EXPRESS = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2012_SP4_EXPRESS"
    WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_JAPANESE_64BIT_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2012_R2_RTM_ENGLISH_64BIT_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_CORE_CONTAINERS = "WINDOWS_SERVER_2016_ENGLISH_CORE_CONTAINERS"
    '''2016 - Start.'''
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_WEB = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_WEB"
    WINDOWS_SERVER_2016_GERMAN_FULL_BASE = "WINDOWS_SERVER_2016_GERMAN_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_DEEP_LEARNING = "WINDOWS_SERVER_2016_ENGLISH_DEEP_LEARNING"
    WINDOWS_SERVER_2016_JAPANESE_FULL_FQL_2016_SP2_WEB = "WINDOWS_SERVER_2016_JAPANESE_FULL_FQL_2016_SP2_WEB"
    WINDOWS_SERVER_2016_KOREAN_FULL_BASE = "WINDOWS_SERVER_2016_KOREAN_FULL_BASE"
    WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2016_POLISH_FULL_BASE = "WINDOWS_SERVER_2016_POLISH_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_CONTAINERS = "WINDOWS_SERVER_2016_ENGLISH_FULL_CONTAINERS"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2016_RUSSIAN_FULL_BASE = "WINDOWS_SERVER_2016_RUSSIAN_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_EXPRESS"
    WINDOWS_SERVER_2016_ITALIAN_FULL_BASE = "WINDOWS_SERVER_2016_ITALIAN_FULL_BASE"
    WINDOWS_SERVER_2016_SPANISH_FULL_BASE = "WINDOWS_SERVER_2016_SPANISH_FULL_BASE"
    WINDOWS_SERVER_2012_RTM_GERMAN_64BIT_BASE = "WINDOWS_SERVER_2012_RTM_GERMAN_64BIT_BASE"
    WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2008_R2_SP3_STANDARD = "WINDOWS_SERVER_2012_RTM_JAPANESE_64BIT_SQL_2008_R2_SP3_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_HYPERV = "WINDOWS_SERVER_2016_ENGLISH_FULL_HYPERV"
    WINDOWS_SERVER_2016_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_2016_ENGLISH_CORE_CONTAINERSLATEST"
    WINDOWS_SERVER_2016_DUTCH_FULL_BASE = "WINDOWS_SERVER_2016_DUTCH_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2016_HUNGARIAN_FULL_BASE = "WINDOWS_SERVER_2016_HUNGARIAN_FULL_BASE"
    WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_CORE_BASE = "WINDOWS_SERVER_2016_ENGLISH_CORE_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_BASE = "WINDOWS_SERVER_2016_ENGLISH_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_WEB"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_ENTERPRISE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_WEB = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_WEB"
    WINDOWS_SERVER_2016_SWEDISH_FULL_BASE = "WINDOWS_SERVER_2016_SWEDISH_FULL_BASE"
    WINDOWS_SERVER_2016_TURKISH_FULL_BASE = "WINDOWS_SERVER_2016_TURKISH_FULL_BASE"
    WINDOWS_SERVER_2016_PORTUGUESE_BRAZIL_FULL_BASE = "WINDOWS_SERVER_2016_PORTUGUESE_BRAZIL_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2014_SP3_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2014_SP3_STANDARD"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_64BIT_SQL_2012_SP4_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_WEB = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_WEB"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2016_PORTUGUESE_PORTUGAL_FULL_BASE = "WINDOWS_SERVER_2016_PORTUGUESE_PORTUGAL_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2014_SP3_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2014_SP3_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_EXPRESS"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_WEB"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_STIG_CORE = "WINDOWS_SERVER_2016_ENGLISH_STIG_CORE"
    WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2016_KOREAN_FULL_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_FULL_ECS_OPTIMIZED = "WINDOWS_SERVER_2016_ENGLISH_FULL_ECS_OPTIMIZED"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_WEB = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_WEB"
    WINDOWS_SERVER_2016_ENGLISH_P3 = "WINDOWS_SERVER_2016_ENGLISH_P3"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_ENTERPRISE = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_ENTERPRISE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_BASE = "WINDOWS_SERVER_2016_JAPANESE_FULL_BASE"
    WINDOWS_SERVER_2016_CHINESE_SIMPLIFIED_FULL_BASE = "WINDOWS_SERVER_2016_CHINESE_SIMPLIFIED_FULL_BASE"
    WINDOWS_SERVER_2016_FRENCH_FULL_BASE = "WINDOWS_SERVER_2016_FRENCH_FULL_BASE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2016_CZECH_FULL_BASE = "WINDOWS_SERVER_2016_CZECH_FULL_BASE"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_STANDARD = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2016_CHINESE_TRADITIONAL_FULL_BASE = "WINDOWS_SERVER_2016_CHINESE_TRADITIONAL_FULL_BASE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_WEB = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP2_WEB"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2017_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2016_ENGLISH_TESLA = "WINDOWS_SERVER_2016_ENGLISH_TESLA"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_STIG_FULL = "WINDOWS_SERVER_2016_ENGLISH_STIG_FULL"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2016_ENGLISH_CORE_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_EXPRESS = "WINDOWS_SERVER_2016_JAPANESE_FULL_SQL_2016_SP1_EXPRESS"
    WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_ENTERPRISE = "WINDOWS_SERVER_2016_ENGLISH_FULL_SQL_2016_SP1_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_WEB"
    '''2019 - Start.'''
    WINDOWS_SERVER_2019_FRENCH_FULL_BASE = "WINDOWS_SERVER_2019_FRENCH_FULL_BASE"
    WINDOWS_SERVER_2019_KOREAN_FULL_BASE = "WINDOWS_SERVER_2019_KOREAN_FULL_BASE"
    WINDOWS_SERVER_2019_ITALIAN_FULL_BASE = "WINDOWS_SERVER_2019_ITALIAN_FULL_BASE"
    WINDOWS_SERVER_2019_CHINESE_SIMPLIFIED_FULL_BASE = "WINDOWS_SERVER_2019_CHINESE_SIMPLIFIED_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_WEB = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_HYPERV = "WINDOWS_SERVER_2019_ENGLISH_FULL_HYPERV"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_STANDARD = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_STANDARD"
    WINDOWS_SERVER_2019_HUNGARIAN_FULL_BASE = "WINDOWS_SERVER_2019_HUNGARIAN_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_EXPRESS = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_EXPRESS"
    WINDOWS_SERVER_2019_TURKISH_FULL_BASE = "WINDOWS_SERVER_2019_TURKISH_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2019_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_2019_ENGLISH_CORE_CONTAINERSLATEST"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_EXPRESS = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_EXPRESS"
    WINDOWS_SERVER_2019_JAPANESE_FULL_BASE = "WINDOWS_SERVER_2019_JAPANESE_FULL_BASE"
    WINDOWS_SERVER_2019_RUSSIAN_FULL_BASE = "WINDOWS_SERVER_2019_RUSSIAN_FULL_BASE"
    WINDOWS_SERVER_2019_CHINESE_TRADITIONAL_FULL_BASE = "WINDOWS_SERVER_2019_CHINESE_TRADITIONAL_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_CORE_BASE = "WINDOWS_SERVER_2019_ENGLISH_CORE_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_BASE = "WINDOWS_SERVER_2019_ENGLISH_FULL_BASE"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_STANDARD = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_STANDARD"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_ENTERPRISE = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_TESLA = "WINDOWS_SERVER_2019_ENGLISH_TESLA"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2019_SPANISH_FULL_BASE = "WINDOWS_SERVER_2019_SPANISH_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_ENTERPRISE = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_STIG_FULL = "WINDOWS_SERVER_2019_ENGLISH_STIG_FULL"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_WEB = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_STANDARD = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_STANDARD"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_ENTERPRISE = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP2_ENTERPRISE"
    WINDOWS_SERVER_2019_PORTUGUESE_PORTUGAL_FULL_BASE = "WINDOWS_SERVER_2019_PORTUGUESE_PORTUGAL_FULL_BASE"
    WINDOWS_SERVER_2019_SWEDISH_FULL_BASE = "WINDOWS_SERVER_2019_SWEDISH_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_EXPRESS = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_EXPRESS"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_WEB = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2022_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_ENTERPRISE = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_WEB = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2019_PORTUGUESE_BRAZIL_FULL_BASE = "WINDOWS_SERVER_2019_PORTUGUESE_BRAZIL_FULL_BASE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_CONTAINERSLATEST = "WINDOWS_SERVER_2019_ENGLISH_FULL_CONTAINERSLATEST"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_EXPRESS = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2019_EXPRESS"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_EXPRESS = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2016_SP3_EXPRESS"
    WINDOWS_SERVER_2019_ENGLISH_STIG_CORE = "WINDOWS_SERVER_2019_ENGLISH_STIG_CORE"
    WINDOWS_SERVER_2019_ENGLISH_CORE_ECS_OPTIMIZED = "WINDOWS_SERVER_2019_ENGLISH_CORE_ECS_OPTIMIZED"
    WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_STANDARD = "WINDOWS_SERVER_2019_ENGLISH_FULL_SQL_2022_STANDARD"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2019_ENGLISH_FULL_ECS_OPTIMIZED = "WINDOWS_SERVER_2019_ENGLISH_FULL_ECS_OPTIMIZED"
    WINDOWS_SERVER_2019_ENGLISH_DEEP_LEARNING = "WINDOWS_SERVER_2019_ENGLISH_DEEP_LEARNING"
    WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2019_JAPANESE_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2019_CZECH_FULL_BASE = "WINDOWS_SERVER_2019_CZECH_FULL_BASE"
    WINDOWS_SERVER_2019_POLISH_FULL_BASE = "WINDOWS_SERVER_2019_POLISH_FULL_BASE"
    WINDOWS_SERVER_2019_GERMAN_FULL_BASE = "WINDOWS_SERVER_2019_GERMAN_FULL_BASE"
    WINDOWS_SERVER_2019_DUTCH_FULL_BASE = "WINDOWS_SERVER_2019_DUTCH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_STIG_FULL = "WINDOWS_SERVER_2022_ENGLISH_STIG_FULL"
    '''2022 - Start.'''
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_WEB = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_WEB"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_WEB = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_WEB"
    WINDOWS_SERVER_2022_ENGLISH_STIG_CORE = "WINDOWS_SERVER_2022_ENGLISH_STIG_CORE"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2022_PORTUGUESE_BRAZIL_FULL_BASE = "WINDOWS_SERVER_2022_PORTUGUESE_BRAZIL_FULL_BASE"
    WINDOWS_SERVER_2022_ITALIAN_FULL_BASE = "WINDOWS_SERVER_2022_ITALIAN_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_CONTAINERSLATEST = "WINDOWS_SERVER_2022_ENGLISH_FULL_CONTAINERSLATEST"
    WINDOWS_SERVER_2022_RUSSIAN_FULL_BASE = "WINDOWS_SERVER_2022_RUSSIAN_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_EXPRESS = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_EXPRESS"
    WINDOWS_SERVER_2022_POLISH_FULL_BASE = "WINDOWS_SERVER_2022_POLISH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_CORE_BASE = "WINDOWS_SERVER_2022_ENGLISH_CORE_BASE"
    WINDOWS_SERVER_2022_HUNGARIAN_FULL_BASE = "WINDOWS_SERVER_2022_HUNGARIAN_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_EXPRESS = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_EXPRESS"
    WINDOWS_SERVER_2022_GERMAN_FULL_BASE = "WINDOWS_SERVER_2022_GERMAN_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_CORE_CONTAINERSLATEST = "WINDOWS_SERVER_2022_ENGLISH_CORE_CONTAINERSLATEST"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_WEB"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_WEB = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_WEB"
    WINDOWS_SERVER_2022_JAPANESE_FULL_BASE = "WINDOWS_SERVER_2022_JAPANESE_FULL_BASE"
    WINDOWS_SERVER_2022_KOREAN_FULL_BASE = "WINDOWS_SERVER_2022_KOREAN_FULL_BASE"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_STANDARD = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_STANDARD"
    WINDOWS_SERVER_2022_CHINESE_SIMPLIFIED_FULL_BASE = "WINDOWS_SERVER_2022_CHINESE_SIMPLIFIED_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2022_SPANISH_FULL_BASE = "WINDOWS_SERVER_2022_SPANISH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_CORE_ECS_OPTIMIZED = "WINDOWS_SERVER_2022_ENGLISH_CORE_ECS_OPTIMIZED"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2022_CHINESE_TRADITIONAL_FULL_BASE = "WINDOWS_SERVER_2022_CHINESE_TRADITIONAL_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_ENTERPRISE = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2019_ENTERPRISE"
    WINDOWS_SERVER_2022_FRENCH_FULL_BASE = "WINDOWS_SERVER_2022_FRENCH_FULL_BASE"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_STANDARD = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2017_STANDARD"
    WINDOWS_SERVER_2022_ENGLISH_FULL_BASE = "WINDOWS_SERVER_2022_ENGLISH_FULL_BASE"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_WEB = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2019_WEB"
    WINDOWS_SERVER_2022_TURKISH_FULL_BASE = "WINDOWS_SERVER_2022_TURKISH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_ENTERPRISE = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2017_ENTERPRISE"
    WINDOWS_SERVER_2022_PORTUGUESE_PORTUGAL_FULL_BASE = "WINDOWS_SERVER_2022_PORTUGUESE_PORTUGAL_FULL_BASE"
    WINDOWS_SERVER_2022_CZECH_FULL_BASE = "WINDOWS_SERVER_2022_CZECH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_ECS_OPTIMIZED = "WINDOWS_SERVER_2022_ENGLISH_FULL_ECS_OPTIMIZED"
    WINDOWS_SERVER_2022_DUTCH_FULL_BASE = "WINDOWS_SERVER_2022_DUTCH_FULL_BASE"
    WINDOWS_SERVER_2022_SWEDISH_FULL_BASE = "WINDOWS_SERVER_2022_SWEDISH_FULL_BASE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_ENTERPRISE = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_ENTERPRISE"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_EXPRESS = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_EXPRESS"
    WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_STANDARD = "WINDOWS_SERVER_2022_ENGLISH_FULL_SQL_2022_STANDARD"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_STANDARD = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_STANDARD"
    WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_ENTERPRISE = "WINDOWS_SERVER_2022_JAPANESE_FULL_SQL_2022_ENTERPRISE"


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2022ImageSsmParameterProps",
    jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "user_data": "userData",
        "cpu_type": "cpuType",
        "edition": "edition",
        "kernel": "kernel",
    },
)
class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptions):
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        kernel: typing.Optional[AmazonLinux2022Kernel] = None,
    ) -> None:
        '''Properties specific to al2022 images.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # amazon_linux2022_kernel: ec2.AmazonLinux2022Kernel
            # user_data: ec2.UserData
            
            amazon_linux2022_image_ssm_parameter_props = ec2.AmazonLinux2022ImageSsmParameterProps(
                cached_in_context=False,
                cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
                edition=ec2.AmazonLinuxEdition.STANDARD,
                kernel=amazon_linux2022_kernel,
                user_data=user_data
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__968329b6e3d88dbd1836e6234bc305a96628c570666cc423d4eeccc95dc92ab6)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
            check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
            check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data
        if cpu_type is not None:
            self._values["cpu_type"] = cpu_type
        if edition is not None:
            self._values["edition"] = edition
        if kernel is not None:
            self._values["kernel"] = kernel

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional[UserData]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional[UserData], result)

    @builtins.property
    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
        '''CPU Type.

        :default: AmazonLinuxCpuType.X86_64
        '''
        result = self._values.get("cpu_type")
        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)

    @builtins.property
    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
        '''What edition of Amazon Linux to use.

        :default: AmazonLinuxEdition.Standard
        '''
        result = self._values.get("edition")
        return typing.cast(typing.Optional[AmazonLinuxEdition], result)

    @builtins.property
    def kernel(self) -> typing.Optional[AmazonLinux2022Kernel]:
        '''What kernel version of Amazon Linux to use.

        :default: AmazonLinux2022Kernel.DEFAULT
        '''
        result = self._values.get("kernel")
        return typing.cast(typing.Optional[AmazonLinux2022Kernel], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinux2022ImageSsmParameterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2023ImageSsmParameterProps",
    jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "user_data": "userData",
        "cpu_type": "cpuType",
        "edition": "edition",
        "kernel": "kernel",
    },
)
class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptions):
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        kernel: typing.Optional[AmazonLinux2023Kernel] = None,
    ) -> None:
        '''Properties specific to al2023 images.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            
            
            ec2.Instance(self, "LatestAl2023",
                vpc=vpc,
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
                machine_image=ec2.MachineImage.latest_amazon_linux2023(
                    cached_in_context=True
                )
            )
            
            # or
            ec2.Instance(self, "LatestAl2023",
                vpc=vpc,
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
                # context cache is turned on by default
                machine_image=ec2.AmazonLinux2023ImageSsmParameter()
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2a291560388da3a1deca6cc63773b445813e32521bbcf4ece1d3a557e2eda6b)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
            check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
            check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data
        if cpu_type is not None:
            self._values["cpu_type"] = cpu_type
        if edition is not None:
            self._values["edition"] = edition
        if kernel is not None:
            self._values["kernel"] = kernel

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional[UserData]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional[UserData], result)

    @builtins.property
    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
        '''CPU Type.

        :default: AmazonLinuxCpuType.X86_64
        '''
        result = self._values.get("cpu_type")
        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)

    @builtins.property
    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
        '''What edition of Amazon Linux to use.

        :default: AmazonLinuxEdition.Standard
        '''
        result = self._values.get("edition")
        return typing.cast(typing.Optional[AmazonLinuxEdition], result)

    @builtins.property
    def kernel(self) -> typing.Optional[AmazonLinux2023Kernel]:
        '''What kernel version of Amazon Linux to use.

        :default: AmazonLinux2023Kernel.DEFAULT
        '''
        result = self._values.get("kernel")
        return typing.cast(typing.Optional[AmazonLinux2023Kernel], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinux2023ImageSsmParameterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2ImageSsmParameterProps",
    jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
    name_mapping={
        "cached_in_context": "cachedInContext",
        "user_data": "userData",
        "cpu_type": "cpuType",
        "edition": "edition",
        "kernel": "kernel",
        "storage": "storage",
        "virtualization": "virtualization",
    },
)
class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptions):
    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        kernel: typing.Optional[AmazonLinux2Kernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
    ) -> None:
        '''Properties specific to amzn2 images.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param virtualization: Virtualization type. Default: HVM

        :exampleMetadata: infused

        Example::

            # vpc: ec2.Vpc
            # instance_type: ec2.InstanceType
            
            
            # Amazon Linux 2
            ec2.Instance(self, "Instance2",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=ec2.MachineImage.latest_amazon_linux2()
            )
            
            # Amazon Linux 2 with kernel 5.x
            ec2.Instance(self, "Instance3",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=ec2.MachineImage.latest_amazon_linux2(
                    kernel=ec2.AmazonLinux2Kernel.KERNEL_5_10
                )
            )
            
            # Amazon Linux 2023
            ec2.Instance(self, "Instance4",
                vpc=vpc,
                instance_type=instance_type,
                machine_image=ec2.MachineImage.latest_amazon_linux2023()
            )
            
            # Graviton 3 Processor
            ec2.Instance(self, "Instance5",
                vpc=vpc,
                instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
                machine_image=ec2.MachineImage.latest_amazon_linux2023(
                    cpu_type=ec2.AmazonLinuxCpuType.ARM_64
                )
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8aa3dd8e9489482da5f68eebe827af2a2367490c7299028616bae30c26efbd55)
            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
            check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
            check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
            check_type(argname="argument storage", value=storage, expected_type=type_hints["storage"])
            check_type(argname="argument virtualization", value=virtualization, expected_type=type_hints["virtualization"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cached_in_context is not None:
            self._values["cached_in_context"] = cached_in_context
        if user_data is not None:
            self._values["user_data"] = user_data
        if cpu_type is not None:
            self._values["cpu_type"] = cpu_type
        if edition is not None:
            self._values["edition"] = edition
        if kernel is not None:
            self._values["kernel"] = kernel
        if storage is not None:
            self._values["storage"] = storage
        if virtualization is not None:
            self._values["virtualization"] = virtualization

    @builtins.property
    def cached_in_context(self) -> typing.Optional[builtins.bool]:
        '''Whether the AMI ID is cached to be stable between deployments.

        By default, the newest image is used on each deployment. This will cause
        instances to be replaced whenever a new version is released, and may cause
        downtime if there aren't enough running instances in the AutoScalingGroup
        to reschedule the tasks on.

        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
        same value will be used on future runs. Your instances will not be replaced
        but your AMI version will grow old over time. To refresh the AMI lookup,
        you will have to evict the value from the cache using the ``cdk context``
        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
        more information.

        Can not be set to ``true`` in environment-agnostic stacks.

        :default: false
        '''
        result = self._values.get("cached_in_context")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def user_data(self) -> typing.Optional[UserData]:
        '''Initial user data.

        :default: - Empty UserData for Linux machines
        '''
        result = self._values.get("user_data")
        return typing.cast(typing.Optional[UserData], result)

    @builtins.property
    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
        '''CPU Type.

        :default: AmazonLinuxCpuType.X86_64
        '''
        result = self._values.get("cpu_type")
        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)

    @builtins.property
    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
        '''What edition of Amazon Linux to use.

        :default: AmazonLinuxEdition.Standard
        '''
        result = self._values.get("edition")
        return typing.cast(typing.Optional[AmazonLinuxEdition], result)

    @builtins.property
    def kernel(self) -> typing.Optional[AmazonLinux2Kernel]:
        '''What kernel version of Amazon Linux to use.

        :default: -
        '''
        result = self._values.get("kernel")
        return typing.cast(typing.Optional[AmazonLinux2Kernel], result)

    @builtins.property
    def storage(self) -> typing.Optional[AmazonLinuxStorage]:
        '''What storage backed image to use.

        :default: GeneralPurpose
        '''
        result = self._values.get("storage")
        return typing.cast(typing.Optional[AmazonLinuxStorage], result)

    @builtins.property
    def virtualization(self) -> typing.Optional[AmazonLinuxVirt]:
        '''Virtualization type.

        :default: HVM
        '''
        result = self._values.get("virtualization")
        return typing.cast(typing.Optional[AmazonLinuxVirt], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AmazonLinux2ImageSsmParameterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IMachineImage)
class AmazonLinuxImageSsmParameterBase(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBase",
):
    def __init__(
        self,
        *,
        parameter_name: builtins.str,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param parameter_name: The name of the SSM parameter that contains the AMI value.
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinuxImageSsmParameterBaseProps(
            parameter_name=parameter_name,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cf74508a9d2ec0bb2e7646472ba3fe700482482a3d87536fb58694a37fa01191)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [scope]))


class _AmazonLinuxImageSsmParameterBaseProxy(AmazonLinuxImageSsmParameterBase):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, AmazonLinuxImageSsmParameterBase).__jsii_proxy_class__ = lambda : _AmazonLinuxImageSsmParameterBaseProxy


@jsii.implements(IInstance)
class BastionHostLinux(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.BastionHostLinux",
):
    '''This creates a linux bastion host you can use to connect to other instances or services in your VPC.

    The recommended way to connect to the bastion host is by using AWS Systems Manager Session Manager.

    The operating system is Amazon Linux 2 with the latest SSM agent installed

    You can also configure this bastion host to allow connections via SSH

    :resource: AWS::EC2::Instance
    :exampleMetadata: fixture=with-vpc infused

    Example::

        host = ec2.BastionHostLinux(self, "BastionHost",
            vpc=vpc,
            block_devices=[ec2.BlockDevice(
                device_name="EBSBastionHost",
                volume=ec2.BlockDeviceVolume.ebs(10,
                    encrypted=True
                )
            )]
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        availability_zone: typing.Optional[builtins.str] = None,
        block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
        init: typing.Optional[CloudFormationInit] = None,
        init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
        instance_name: typing.Optional[builtins.str] = None,
        instance_type: typing.Optional[InstanceType] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        require_imdsv2: typing.Optional[builtins.bool] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
        subnet_selection: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: VPC to launch the instance in.
        :param availability_zone: In which AZ to place the instance within the VPC. Default: - Random zone.
        :param block_devices: Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes. Each instance that is launched has an associated root device volume, either an Amazon EBS volume or an instance store volume. You can use block device mappings to specify additional EBS volumes or instance store volumes to attach to an instance when it is launched. Default: - Uses the block device mapping of the AMI
        :param init: Apply the given CloudFormation Init configuration to the instance at startup. Default: - no CloudFormation init
        :param init_options: Use the given options for applying CloudFormation Init. Describes the configsets to use and the timeout to wait Default: - default options
        :param instance_name: The name of the instance. Default: 'BastionHost'
        :param instance_type: Type of instance to launch. Default: 't3.nano'
        :param machine_image: The machine image to use, assumed to have SSM Agent preinstalled. Default: - An Amazon Linux 2 image which is kept up-to-date automatically (the instance may be replaced on every deployment) and already has SSM Agent installed.
        :param require_imdsv2: Whether IMDSv2 should be required on this instance. Default: - false
        :param security_group: Security Group to assign to this instance. Default: - create new security group with no inbound and all outbound traffic allowed
        :param subnet_selection: Select the subnets to run the bastion host in. Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM. You have to allow port 22 manually by using the connections field Default: - private subnets of the supplied VPC
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__92a5b88f3339020054ea1e16e9617c17798da0b874294e4200a9b8e5bf598a4b)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BastionHostLinuxProps(
            vpc=vpc,
            availability_zone=availability_zone,
            block_devices=block_devices,
            init=init,
            init_options=init_options,
            instance_name=instance_name,
            instance_type=instance_type,
            machine_image=machine_image,
            require_imdsv2=require_imdsv2,
            security_group=security_group,
            subnet_selection=subnet_selection,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="allowSshAccessFrom")
    def allow_ssh_access_from(self, *peer: IPeer) -> None:
        '''Allow SSH access from the given peer or peers.

        Necessary if you want to connect to the instance using ssh. If not
        called, you should use SSM Session Manager to connect to the instance.

        :param peer: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f382d5533c0ebd9e4acd85dbfb1d41bb8c0048a0e29c6a90326f07a2f2cd1cf1)
            check_type(argname="argument peer", value=peer, expected_type=typing.Tuple[type_hints["peer"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "allowSshAccessFrom", [*peer]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''Allows specify security group connections for the instance.'''
        return typing.cast("Connections", jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="grantPrincipal")
    def grant_principal(self) -> _IPrincipal_539bb2fd:
        '''The principal to grant permissions to.'''
        return typing.cast(_IPrincipal_539bb2fd, jsii.get(self, "grantPrincipal"))

    @builtins.property
    @jsii.member(jsii_name="instance")
    def instance(self) -> Instance:
        '''The underlying instance resource.'''
        return typing.cast(Instance, jsii.get(self, "instance"))

    @builtins.property
    @jsii.member(jsii_name="instanceAvailabilityZone")
    def instance_availability_zone(self) -> builtins.str:
        '''The availability zone the instance was launched in.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceAvailabilityZone"))

    @builtins.property
    @jsii.member(jsii_name="instanceId")
    def instance_id(self) -> builtins.str:
        '''The instance's ID.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instanceId"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateDnsName")
    def instance_private_dns_name(self) -> builtins.str:
        '''Private DNS name for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePrivateIp")
    def instance_private_ip(self) -> builtins.str:
        '''Private IP for this instance.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePrivateIp"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicDnsName")
    def instance_public_dns_name(self) -> builtins.str:
        '''Publicly-routable DNS name for this instance.

        (May be an empty string if the instance does not have a public name).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicDnsName"))

    @builtins.property
    @jsii.member(jsii_name="instancePublicIp")
    def instance_public_ip(self) -> builtins.str:
        '''Publicly-routable IP  address for this instance.

        (May be an empty string if the instance does not have a public IP).

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "instancePublicIp"))

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> _IRole_235f5d8e:
        '''The IAM role assumed by the instance.'''
        return typing.cast(_IRole_235f5d8e, jsii.get(self, "role"))

    @builtins.property
    @jsii.member(jsii_name="stack")
    def stack(self) -> _Stack_2866e57f:
        '''The stack in which this resource is defined.'''
        return typing.cast(_Stack_2866e57f, jsii.get(self, "stack"))


@jsii.implements(IConnectable)
class Connections(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_ec2.Connections"):
    '''Manage the allowed network connections for constructs with Security Groups.

    Security Groups can be thought of as a firewall for network-connected
    devices. This class makes it easy to allow network connections to and
    from security groups, and between security groups individually. When
    establishing connectivity between security groups, it will automatically
    add rules in both security groups

    This object can manage one or more security groups.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # peer: ec2.IPeer
        # port: ec2.Port
        # security_group: ec2.SecurityGroup
        
        connections = ec2.Connections(
            default_port=port,
            peer=peer,
            security_groups=[security_group]
        )
    '''

    def __init__(
        self,
        *,
        default_port: typing.Optional[Port] = None,
        peer: typing.Optional[IPeer] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    ) -> None:
        '''
        :param default_port: Default port range for initiating connections to and from this object. Default: - No default port
        :param peer: Class that represents the rule by which others can connect to this connectable. This object is required, but will be derived from securityGroup if that is passed. Default: Derived from securityGroup if set.
        :param security_groups: What securityGroup(s) this object is managing connections for. Default: No security groups
        '''
        props = ConnectionsProps(
            default_port=default_port, peer=peer, security_groups=security_groups
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="addSecurityGroup")
    def add_security_group(self, *security_groups: ISecurityGroup) -> None:
        '''Add a security group to the list of security groups managed by this object.

        :param security_groups: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30f9648f95fcf6fd4777a67fd46cb5949fb6a0fd2a05b9f89e5cbfe639768592)
            check_type(argname="argument security_groups", value=security_groups, expected_type=typing.Tuple[type_hints["security_groups"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addSecurityGroup", [*security_groups]))

    @jsii.member(jsii_name="allowDefaultPortFrom")
    def allow_default_port_from(
        self,
        other: IConnectable,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow connections from the peer on our default port.

        Even if the peer has a default port, we will always use our default port.

        :param other: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4af926db4317778330f9d27a35269bd7cc1ff141c2e618cd3478e604ab2cf611)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowDefaultPortFrom", [other, description]))

    @jsii.member(jsii_name="allowDefaultPortFromAnyIpv4")
    def allow_default_port_from_any_ipv4(
        self,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow default connections from all IPv4 ranges.

        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a3434f5301bd66f7d9f8219fdf272e0d2c6df758a9c3fd0cdd6179b48ee5580d)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowDefaultPortFromAnyIpv4", [description]))

    @jsii.member(jsii_name="allowDefaultPortInternally")
    def allow_default_port_internally(
        self,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow hosts inside the security group to connect to each other.

        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0fcdad0b62419eb5e4d9089b7ea98359f3c29807c8283229458362a66f03a663)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowDefaultPortInternally", [description]))

    @jsii.member(jsii_name="allowDefaultPortTo")
    def allow_default_port_to(
        self,
        other: IConnectable,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow connections from the peer on our default port.

        Even if the peer has a default port, we will always use our default port.

        :param other: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__497f73425da5460739cd6f136e19606e6ddef368deba9569817e65819373ecb4)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowDefaultPortTo", [other, description]))

    @jsii.member(jsii_name="allowFrom")
    def allow_from(
        self,
        other: IConnectable,
        port_range: Port,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow connections from the peer on the given port.

        :param other: -
        :param port_range: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6572dc434576da890fbd1b2b5646ecfb304d9804cac739c802d1ee3385a4f805)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowFrom", [other, port_range, description]))

    @jsii.member(jsii_name="allowFromAnyIpv4")
    def allow_from_any_ipv4(
        self,
        port_range: Port,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow from any IPv4 ranges.

        :param port_range: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__69cadabf21c2afae1671de35428d0d256a4b57c3e6b3a1334a81e6b9f4c68a3e)
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowFromAnyIpv4", [port_range, description]))

    @jsii.member(jsii_name="allowInternally")
    def allow_internally(
        self,
        port_range: Port,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow hosts inside the security group to connect to each other on the given port.

        :param port_range: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d47a2facfac8c0ecfe23ef6fee5c7521694632daed038efdf40f6905580b1ac4)
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowInternally", [port_range, description]))

    @jsii.member(jsii_name="allowTo")
    def allow_to(
        self,
        other: IConnectable,
        port_range: Port,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow connections to the peer on the given port.

        :param other: -
        :param port_range: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1b8ec7d81796ed570e693d5d24043c9d7d899f406915c45c1598080c2100ebf5)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowTo", [other, port_range, description]))

    @jsii.member(jsii_name="allowToAnyIpv4")
    def allow_to_any_ipv4(
        self,
        port_range: Port,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow to all IPv4 ranges.

        :param port_range: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f82fae2c4334767a87dcacbb402c6b4b78707b965538b5938f6bb6804fc9a4fb)
            check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowToAnyIpv4", [port_range, description]))

    @jsii.member(jsii_name="allowToDefaultPort")
    def allow_to_default_port(
        self,
        other: IConnectable,
        description: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Allow connections to the security group on their default port.

        :param other: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b918508ccd5634d9e6d60756886cb3101d18d6f4387382a5447e3f16eee02b2)
            check_type(argname="argument other", value=other, expected_type=type_hints["other"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        return typing.cast(None, jsii.invoke(self, "allowToDefaultPort", [other, description]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> "Connections":
        '''The network connections associated with this resource.'''
        return typing.cast("Connections", jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="securityGroups")
    def security_groups(self) -> typing.List[ISecurityGroup]:
        return typing.cast(typing.List[ISecurityGroup], jsii.get(self, "securityGroups"))

    @builtins.property
    @jsii.member(jsii_name="defaultPort")
    def default_port(self) -> typing.Optional[Port]:
        '''The default port configured for this connection peer, if available.'''
        return typing.cast(typing.Optional[Port], jsii.get(self, "defaultPort"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.DestinationOptions",
    jsii_struct_bases=[S3DestinationOptions],
    name_mapping={
        "file_format": "fileFormat",
        "hive_compatible_partitions": "hiveCompatiblePartitions",
        "per_hour_partition": "perHourPartition",
    },
)
class DestinationOptions(S3DestinationOptions):
    def __init__(
        self,
        *,
        file_format: typing.Optional[FlowLogFileFormat] = None,
        hive_compatible_partitions: typing.Optional[builtins.bool] = None,
        per_hour_partition: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Options for writing logs to a destination.

        TODO: there are other destination options, currently they are
        only for s3 destinations (not sure if that will change)

        :param file_format: The format for the flow log. Default: FlowLogFileFormat.PLAIN_TEXT
        :param hive_compatible_partitions: Use Hive-compatible prefixes for flow logs stored in Amazon S3. Default: false
        :param per_hour_partition: Partition the flow log per hour. Default: false

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            destination_options = ec2.DestinationOptions(
                file_format=ec2.FlowLogFileFormat.PLAIN_TEXT,
                hive_compatible_partitions=False,
                per_hour_partition=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25320fe03f4bb5eeafb902dcb6105bd03ab5394914423243b762e469d2ecb045)
            check_type(argname="argument file_format", value=file_format, expected_type=type_hints["file_format"])
            check_type(argname="argument hive_compatible_partitions", value=hive_compatible_partitions, expected_type=type_hints["hive_compatible_partitions"])
            check_type(argname="argument per_hour_partition", value=per_hour_partition, expected_type=type_hints["per_hour_partition"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if file_format is not None:
            self._values["file_format"] = file_format
        if hive_compatible_partitions is not None:
            self._values["hive_compatible_partitions"] = hive_compatible_partitions
        if per_hour_partition is not None:
            self._values["per_hour_partition"] = per_hour_partition

    @builtins.property
    def file_format(self) -> typing.Optional[FlowLogFileFormat]:
        '''The format for the flow log.

        :default: FlowLogFileFormat.PLAIN_TEXT
        '''
        result = self._values.get("file_format")
        return typing.cast(typing.Optional[FlowLogFileFormat], result)

    @builtins.property
    def hive_compatible_partitions(self) -> typing.Optional[builtins.bool]:
        '''Use Hive-compatible prefixes for flow logs stored in Amazon S3.

        :default: false
        '''
        result = self._values.get("hive_compatible_partitions")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def per_hour_partition(self) -> typing.Optional[builtins.bool]:
        '''Partition the flow log per hour.

        :default: false
        '''
        result = self._values.get("per_hour_partition")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DestinationOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.EbsDeviceOptions",
    jsii_struct_bases=[EbsDeviceOptionsBase],
    name_mapping={
        "delete_on_termination": "deleteOnTermination",
        "iops": "iops",
        "volume_type": "volumeType",
        "encrypted": "encrypted",
        "kms_key": "kmsKey",
    },
)
class EbsDeviceOptions(EbsDeviceOptionsBase):
    def __init__(
        self,
        *,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional[EbsDeviceVolumeType] = None,
        encrypted: typing.Optional[builtins.bool] = None,
        kms_key: typing.Optional[_IKey_5f11635f] = None,
    ) -> None:
        '''Block device options for an EBS volume.

        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``
        :param encrypted: Specifies whether the EBS volume is encrypted. Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption Default: false
        :param kms_key: The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption. You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances. Default: - If encrypted is true, the default aws/ebs KMS key will be used.

        :exampleMetadata: fixture=with-vpc infused

        Example::

            host = ec2.BastionHostLinux(self, "BastionHost",
                vpc=vpc,
                block_devices=[ec2.BlockDevice(
                    device_name="EBSBastionHost",
                    volume=ec2.BlockDeviceVolume.ebs(10,
                        encrypted=True
                    )
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9009756b359157c5d2b270f95428640becaa73def15e04ee91f0eceba0702608)
            check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
            check_type(argname="argument kms_key", value=kms_key, expected_type=type_hints["kms_key"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if delete_on_termination is not None:
            self._values["delete_on_termination"] = delete_on_termination
        if iops is not None:
            self._values["iops"] = iops
        if volume_type is not None:
            self._values["volume_type"] = volume_type
        if encrypted is not None:
            self._values["encrypted"] = encrypted
        if kms_key is not None:
            self._values["kms_key"] = kms_key

    @builtins.property
    def delete_on_termination(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether to delete the volume when the instance is terminated.

        :default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        '''
        result = self._values.get("delete_on_termination")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS) to provision for the volume.

        Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1``

        The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS,
        you need at least 100 GiB storage on the volume.

        :default: - none, required for ``EbsDeviceVolumeType.IO1``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_type(self) -> typing.Optional[EbsDeviceVolumeType]:
        '''The EBS volume type.

        :default: ``EbsDeviceVolumeType.GP2``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional[EbsDeviceVolumeType], result)

    @builtins.property
    def encrypted(self) -> typing.Optional[builtins.bool]:
        '''Specifies whether the EBS volume is encrypted.

        Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption

        :default: false

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances
        '''
        result = self._values.get("encrypted")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption.

        You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances.

        :default: - If encrypted is true, the default aws/ebs KMS key will be used.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-requirements
        '''
        result = self._values.get("kms_key")
        return typing.cast(typing.Optional[_IKey_5f11635f], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EbsDeviceOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.EbsDeviceProps",
    jsii_struct_bases=[EbsDeviceSnapshotOptions, EbsDeviceOptions],
    name_mapping={
        "delete_on_termination": "deleteOnTermination",
        "iops": "iops",
        "volume_type": "volumeType",
        "volume_size": "volumeSize",
        "encrypted": "encrypted",
        "kms_key": "kmsKey",
        "snapshot_id": "snapshotId",
    },
)
class EbsDeviceProps(EbsDeviceSnapshotOptions, EbsDeviceOptions):
    def __init__(
        self,
        *,
        delete_on_termination: typing.Optional[builtins.bool] = None,
        iops: typing.Optional[jsii.Number] = None,
        volume_type: typing.Optional[EbsDeviceVolumeType] = None,
        volume_size: typing.Optional[jsii.Number] = None,
        encrypted: typing.Optional[builtins.bool] = None,
        kms_key: typing.Optional[_IKey_5f11635f] = None,
        snapshot_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Properties of an EBS block device.

        :param delete_on_termination: Indicates whether to delete the volume when the instance is terminated. Default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        :param iops: The number of I/O operations per second (IOPS) to provision for the volume. Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1`` The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS, you need at least 100 GiB storage on the volume. Default: - none, required for ``EbsDeviceVolumeType.IO1``
        :param volume_type: The EBS volume type. Default: ``EbsDeviceVolumeType.GP2``
        :param volume_size: The volume size, in Gibibytes (GiB). If you specify volumeSize, it must be equal or greater than the size of the snapshot. Default: - The snapshot size
        :param encrypted: Specifies whether the EBS volume is encrypted. Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption Default: false
        :param kms_key: The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption. You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances. Default: - If encrypted is true, the default aws/ebs KMS key will be used.
        :param snapshot_id: The snapshot ID of the volume to use. Default: - No snapshot will be used

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_kms as kms
            
            # key: kms.Key
            
            ebs_device_props = ec2.EbsDeviceProps(
                delete_on_termination=False,
                encrypted=False,
                iops=123,
                kms_key=key,
                snapshot_id="snapshotId",
                volume_size=123,
                volume_type=ec2.EbsDeviceVolumeType.STANDARD
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a0ea3e2bab0709f4d926738afbd8d5ecbd17847b51fb29600f577de41f87b90)
            check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
            check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
            check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
            check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
            check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
            check_type(argname="argument kms_key", value=kms_key, expected_type=type_hints["kms_key"])
            check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if delete_on_termination is not None:
            self._values["delete_on_termination"] = delete_on_termination
        if iops is not None:
            self._values["iops"] = iops
        if volume_type is not None:
            self._values["volume_type"] = volume_type
        if volume_size is not None:
            self._values["volume_size"] = volume_size
        if encrypted is not None:
            self._values["encrypted"] = encrypted
        if kms_key is not None:
            self._values["kms_key"] = kms_key
        if snapshot_id is not None:
            self._values["snapshot_id"] = snapshot_id

    @builtins.property
    def delete_on_termination(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether to delete the volume when the instance is terminated.

        :default: - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)
        '''
        result = self._values.get("delete_on_termination")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def iops(self) -> typing.Optional[jsii.Number]:
        '''The number of I/O operations per second (IOPS) to provision for the volume.

        Must only be set for ``volumeType``: ``EbsDeviceVolumeType.IO1``

        The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS,
        you need at least 100 GiB storage on the volume.

        :default: - none, required for ``EbsDeviceVolumeType.IO1``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("iops")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def volume_type(self) -> typing.Optional[EbsDeviceVolumeType]:
        '''The EBS volume type.

        :default: ``EbsDeviceVolumeType.GP2``

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html
        '''
        result = self._values.get("volume_type")
        return typing.cast(typing.Optional[EbsDeviceVolumeType], result)

    @builtins.property
    def volume_size(self) -> typing.Optional[jsii.Number]:
        '''The volume size, in Gibibytes (GiB).

        If you specify volumeSize, it must be equal or greater than the size of the snapshot.

        :default: - The snapshot size
        '''
        result = self._values.get("volume_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def encrypted(self) -> typing.Optional[builtins.bool]:
        '''Specifies whether the EBS volume is encrypted.

        Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption

        :default: false

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances
        '''
        result = self._values.get("encrypted")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def kms_key(self) -> typing.Optional[_IKey_5f11635f]:
        '''The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption.

        You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances.

        :default: - If encrypted is true, the default aws/ebs KMS key will be used.

        :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-requirements
        '''
        result = self._values.get("kms_key")
        return typing.cast(typing.Optional[_IKey_5f11635f], result)

    @builtins.property
    def snapshot_id(self) -> typing.Optional[builtins.str]:
        '''The snapshot ID of the volume to use.

        :default: - No snapshot will be used
        '''
        result = self._values.get("snapshot_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EbsDeviceProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.EnableVpnGatewayOptions",
    jsii_struct_bases=[VpnGatewayProps],
    name_mapping={
        "type": "type",
        "amazon_side_asn": "amazonSideAsn",
        "vpn_route_propagation": "vpnRoutePropagation",
    },
)
class EnableVpnGatewayOptions(VpnGatewayProps):
    def __init__(
        self,
        *,
        type: builtins.str,
        amazon_side_asn: typing.Optional[jsii.Number] = None,
        vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''Options for the Vpc.enableVpnGateway() method.

        :param type: Default type ipsec.1.
        :param amazon_side_asn: Explicitly specify an Asn or let aws pick an Asn for you. Default: 65000
        :param vpn_route_propagation: Provide an array of subnets where the route propagation should be added. Default: noPropagation

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            # subnet: ec2.Subnet
            # subnet_filter: ec2.SubnetFilter
            
            enable_vpn_gateway_options = ec2.EnableVpnGatewayOptions(
                type="type",
            
                # the properties below are optional
                amazon_side_asn=123,
                vpn_route_propagation=[ec2.SubnetSelection(
                    availability_zones=["availabilityZones"],
                    one_per_az=False,
                    subnet_filters=[subnet_filter],
                    subnet_group_name="subnetGroupName",
                    subnets=[subnet],
                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED
                )]
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__40ceead58c1af4de78870bd84bf9515e090aec12292453d603bc5108a17c74db)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument amazon_side_asn", value=amazon_side_asn, expected_type=type_hints["amazon_side_asn"])
            check_type(argname="argument vpn_route_propagation", value=vpn_route_propagation, expected_type=type_hints["vpn_route_propagation"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
        }
        if amazon_side_asn is not None:
            self._values["amazon_side_asn"] = amazon_side_asn
        if vpn_route_propagation is not None:
            self._values["vpn_route_propagation"] = vpn_route_propagation

    @builtins.property
    def type(self) -> builtins.str:
        '''Default type ipsec.1.'''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def amazon_side_asn(self) -> typing.Optional[jsii.Number]:
        '''Explicitly specify an Asn or let aws pick an Asn for you.

        :default: 65000
        '''
        result = self._values.get("amazon_side_asn")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def vpn_route_propagation(self) -> typing.Optional[typing.List[SubnetSelection]]:
        '''Provide an array of subnets where the route propagation should be added.

        :default: noPropagation
        '''
        result = self._values.get("vpn_route_propagation")
        return typing.cast(typing.Optional[typing.List[SubnetSelection]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EnableVpnGatewayOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IFlowLog)
class FlowLog(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.FlowLog",
):
    '''A VPC flow log.

    :resource: AWS::EC2::FlowLog
    :exampleMetadata: infused

    Example::

        # tgw: ec2.CfnTransitGateway
        
        
        ec2.FlowLog(self, "TransitGatewayFlowLog",
            resource_type=ec2.FlowLogResourceType.from_transit_gateway_id(tgw.ref)
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        resource_type: FlowLogResourceType,
        flow_log_name: typing.Optional[builtins.str] = None,
        destination: typing.Optional[FlowLogDestination] = None,
        log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
        max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
        traffic_type: typing.Optional[FlowLogTrafficType] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param resource_type: The type of resource for which to create the flow log.
        :param flow_log_name: The name of the FlowLog. Since the FlowLog resource doesn't support providing a physical name, the value provided here will be recorded in the ``Name`` tag. Default: CDK generated name
        :param destination: Specifies the type of destination to which the flow log data is to be published. Flow log data can be published to CloudWatch Logs or Amazon S3 Default: FlowLogDestinationType.toCloudWatchLogs()
        :param log_format: The fields to include in the flow log record, in the order in which they should appear. If multiple fields are specified, they will be separated by spaces. For full control over the literal log format string, pass a single field constructed with ``LogFormat.custom()``. See https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records Default: - default log format is used.
        :param max_aggregation_interval: The maximum interval of time during which a flow of packets is captured and aggregated into a flow log record. When creating flow logs for a Transit Gateway or Transit Gateway Attachment, this property must be ONE_MINUTES. Default: - FlowLogMaxAggregationInterval.ONE_MINUTES if creating flow logs for Transit Gateway, otherwise FlowLogMaxAggregationInterval.TEN_MINUTES.
        :param traffic_type: The type of traffic to log. You can log traffic that the resource accepts or rejects, or all traffic. When the target is either ``TransitGateway`` or ``TransitGatewayAttachment``, setting the traffic type is not possible. Default: ALL
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ced78745f055b0a1f364c3ae5aeea5e8a341f9b6e72dd88f0e68c7fc2d98cc15)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = FlowLogProps(
            resource_type=resource_type,
            flow_log_name=flow_log_name,
            destination=destination,
            log_format=log_format,
            max_aggregation_interval=max_aggregation_interval,
            traffic_type=traffic_type,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromFlowLogId")
    @builtins.classmethod
    def from_flow_log_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        flow_log_id: builtins.str,
    ) -> IFlowLog:
        '''Import a Flow Log by it's Id.

        :param scope: -
        :param id: -
        :param flow_log_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dfa0067c45ff01fc5b7b18a93e712842dd36455d40f82bd6f8dbcefab3c653dd)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument flow_log_id", value=flow_log_id, expected_type=type_hints["flow_log_id"])
        return typing.cast(IFlowLog, jsii.sinvoke(cls, "fromFlowLogId", [scope, id, flow_log_id]))

    @builtins.property
    @jsii.member(jsii_name="flowLogId")
    def flow_log_id(self) -> builtins.str:
        '''The Id of the VPC Flow Log.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "flowLogId"))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> typing.Optional[_IBucket_42e086fd]:
        '''The S3 bucket to publish flow logs to.'''
        return typing.cast(typing.Optional[_IBucket_42e086fd], jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="deliveryStreamArn")
    def delivery_stream_arn(self) -> typing.Optional[builtins.str]:
        '''The ARN of the Kinesis Data Firehose delivery stream to publish flow logs to.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "deliveryStreamArn"))

    @builtins.property
    @jsii.member(jsii_name="iamRole")
    def iam_role(self) -> typing.Optional[_IRole_235f5d8e]:
        '''The iam role used to publish logs to CloudWatch.'''
        return typing.cast(typing.Optional[_IRole_235f5d8e], jsii.get(self, "iamRole"))

    @builtins.property
    @jsii.member(jsii_name="keyPrefix")
    def key_prefix(self) -> typing.Optional[builtins.str]:
        '''S3 bucket key prefix to publish the flow logs under.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "keyPrefix"))

    @builtins.property
    @jsii.member(jsii_name="logGroup")
    def log_group(self) -> typing.Optional[_ILogGroup_3c4fa718]:
        '''The CloudWatch Logs LogGroup to publish flow logs to.'''
        return typing.cast(typing.Optional[_ILogGroup_3c4fa718], jsii.get(self, "logGroup"))


@jsii.implements(IGatewayVpcEndpointService)
class GatewayVpcEndpointAwsService(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.GatewayVpcEndpointAwsService",
):
    '''An AWS service for a gateway VPC endpoint.

    :exampleMetadata: lit=aws-ec2/test/integ.vpc-endpoint.lit.ts infused

    Example::

        # Add gateway endpoints when creating the VPC
        vpc = ec2.Vpc(self, "MyVpc",
            gateway_endpoints={
                "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
                    service=ec2.GatewayVpcEndpointAwsService.S3
                )
            }
        )
        
        # Alternatively gateway endpoints can be added on the VPC
        dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
            service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
        )
        
        # This allows to customize the endpoint policy
        dynamo_db_endpoint.add_to_policy(
            iam.PolicyStatement( # Restrict to listing and describing tables
                principals=[iam.AnyPrincipal()],
                actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
                resources=["*"]))
        
        # Add an interface endpoint
        vpc.add_interface_endpoint("EcrDockerEndpoint",
            service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
        )
    '''

    def __init__(
        self,
        name: builtins.str,
        prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param name: The name of the service.
        :param prefix: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8080a5dd19788d6c9b781036167a07af095d42330eb8f6d16be6d15e376362c1)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
        jsii.create(self.__class__, self, [name, prefix])

    @jsii.python.classproperty
    @jsii.member(jsii_name="DYNAMODB")
    def DYNAMODB(cls) -> "GatewayVpcEndpointAwsService":
        return typing.cast("GatewayVpcEndpointAwsService", jsii.sget(cls, "DYNAMODB"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="S3")
    def S3(cls) -> "GatewayVpcEndpointAwsService":
        return typing.cast("GatewayVpcEndpointAwsService", jsii.sget(cls, "S3"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the service.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))


@jsii.implements(IMachineImage)
class GenericLinuxImage(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.GenericLinuxImage",
):
    '''Construct a Linux machine image from an AMI map.

    Linux images IDs are not published to SSM parameter store yet, so you'll have to
    manually specify an AMI map.

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    def __init__(
        self,
        ami_map: typing.Mapping[builtins.str, builtins.str],
        *,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param ami_map: -
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d2c7e50295f087cef1db9b5bb5e8370cec7b96087e793cd5acd56945125f54d)
            check_type(argname="argument ami_map", value=ami_map, expected_type=type_hints["ami_map"])
        props = GenericLinuxImageProps(user_data=user_data)

        jsii.create(self.__class__, self, [ami_map, props])

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fe90514a04aaf5c08a9c469baa518c84e5c6b445bb20b5a77861636475f7c70c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [scope]))


@jsii.implements(IMachineImage)
class GenericSSMParameterImage(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.GenericSSMParameterImage",
):
    '''Select the image based on a given SSM parameter at deployment time of the CloudFormation Stack.

    This Machine Image automatically updates to the latest version on every
    deployment. Be aware this will cause your instances to be replaced when a
    new version of the image becomes available. Do not store stateful information
    on the instance if you are using this image.

    The AMI ID is selected using the values published to the SSM parameter store.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # user_data: ec2.UserData
        
        generic_sSMParameter_image = ec2.GenericSSMParameterImage("parameterName", ec2.OperatingSystemType.LINUX, user_data)
    '''

    def __init__(
        self,
        parameter_name: builtins.str,
        os: OperatingSystemType,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param parameter_name: -
        :param os: -
        :param user_data: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53da7a1359316eaee152ae1cc7bca00d0af7eb26ba075ac5bddd5aa9912762a3)
            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
            check_type(argname="argument os", value=os, expected_type=type_hints["os"])
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
        jsii.create(self.__class__, self, [parameter_name, os, user_data])

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a1ebbd79d9f926ea783969c0851038f3bf4ae5f75f35b363e0d68a4baf8b8890)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [scope]))

    @builtins.property
    @jsii.member(jsii_name="parameterName")
    def parameter_name(self) -> builtins.str:
        '''Name of the SSM parameter we're looking up.'''
        return typing.cast(builtins.str, jsii.get(self, "parameterName"))


@jsii.implements(IMachineImage)
class GenericWindowsImage(
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.GenericWindowsImage",
):
    '''Construct a Windows machine image from an AMI map.

    Allows you to create a generic Windows EC2 , manually specify an AMI map.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # user_data: ec2.UserData
        
        generic_windows_image = ec2.GenericWindowsImage({
            "ami_map_key": "amiMap"
        },
            user_data=user_data
        )
    '''

    def __init__(
        self,
        ami_map: typing.Mapping[builtins.str, builtins.str],
        *,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param ami_map: -
        :param user_data: Initial user data. Default: - Empty UserData for Windows machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c7e8d1ab21a95b9a029a944c484e94c08b2faf50a3360bed6944c76aa2e41cea)
            check_type(argname="argument ami_map", value=ami_map, expected_type=type_hints["ami_map"])
        props = GenericWindowsImageProps(user_data=user_data)

        jsii.create(self.__class__, self, [ami_map, props])

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d6165c6e1acd02f0db3c80a8b9118203038aa37e462f1197306722136997d213)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [scope]))


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IClientVpnEndpoint")
class IClientVpnEndpoint(_IResource_c80c4260, IConnectable, typing_extensions.Protocol):
    '''A client VPN endpoint.'''

    @builtins.property
    @jsii.member(jsii_name="endpointId")
    def endpoint_id(self) -> builtins.str:
        '''The endpoint ID.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="targetNetworksAssociated")
    def target_networks_associated(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force target networks associations.'''
        ...


class _IClientVpnEndpointProxy(
    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
    jsii.proxy_for(IConnectable), # type: ignore[misc]
):
    '''A client VPN endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IClientVpnEndpoint"

    @builtins.property
    @jsii.member(jsii_name="endpointId")
    def endpoint_id(self) -> builtins.str:
        '''The endpoint ID.'''
        return typing.cast(builtins.str, jsii.get(self, "endpointId"))

    @builtins.property
    @jsii.member(jsii_name="targetNetworksAssociated")
    def target_networks_associated(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force target networks associations.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "targetNetworksAssociated"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IClientVpnEndpoint).__jsii_proxy_class__ = lambda : _IClientVpnEndpointProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IGatewayVpcEndpoint")
class IGatewayVpcEndpoint(IVpcEndpoint, typing_extensions.Protocol):
    '''A gateway VPC endpoint.'''

    pass


class _IGatewayVpcEndpointProxy(
    jsii.proxy_for(IVpcEndpoint), # type: ignore[misc]
):
    '''A gateway VPC endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IGatewayVpcEndpoint"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IGatewayVpcEndpoint).__jsii_proxy_class__ = lambda : _IGatewayVpcEndpointProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IInterfaceVpcEndpoint")
class IInterfaceVpcEndpoint(IVpcEndpoint, IConnectable, typing_extensions.Protocol):
    '''An interface VPC endpoint.'''

    pass


class _IInterfaceVpcEndpointProxy(
    jsii.proxy_for(IVpcEndpoint), # type: ignore[misc]
    jsii.proxy_for(IConnectable), # type: ignore[misc]
):
    '''An interface VPC endpoint.'''

    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IInterfaceVpcEndpoint"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInterfaceVpcEndpoint).__jsii_proxy_class__ = lambda : _IInterfaceVpcEndpointProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IPrivateSubnet")
class IPrivateSubnet(ISubnet, typing_extensions.Protocol):
    pass


class _IPrivateSubnetProxy(
    jsii.proxy_for(ISubnet), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IPrivateSubnet"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPrivateSubnet).__jsii_proxy_class__ = lambda : _IPrivateSubnetProxy


@jsii.interface(jsii_type="aws-cdk-lib.aws_ec2.IPublicSubnet")
class IPublicSubnet(ISubnet, typing_extensions.Protocol):
    pass


class _IPublicSubnetProxy(
    jsii.proxy_for(ISubnet), # type: ignore[misc]
):
    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ec2.IPublicSubnet"
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPublicSubnet).__jsii_proxy_class__ = lambda : _IPublicSubnetProxy


class InitCommand(
    InitElement,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InitCommand",
):
    '''Command to execute on the instance.

    :exampleMetadata: infused

    Example::

        handle = ec2.InitServiceRestartHandle()
        ec2.CloudFormationInit.from_elements(
            ec2.InitCommand.shell_command("/usr/bin/custom-nginx-install.sh", service_restart_handles=[handle]),
            ec2.InitService.enable("nginx", service_restart_handle=handle))
    '''

    @jsii.member(jsii_name="argvCommand")
    @builtins.classmethod
    def argv_command(
        cls,
        argv: typing.Sequence[builtins.str],
        *,
        cwd: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        ignore_errors: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        test_cmd: typing.Optional[builtins.str] = None,
        wait_after_completion: typing.Optional[InitCommandWaitDuration] = None,
    ) -> "InitCommand":
        '''Run a command from an argv array.

        You do not need to escape space characters or enclose command parameters in quotes.

        :param argv: -
        :param cwd: The working directory. Default: - Use default working directory
        :param env: Sets environment variables for the command. This property overwrites, rather than appends, the existing environment. Default: - Use current environment
        :param ignore_errors: Continue running if this command fails. Default: false
        :param key: Identifier key for this command. Commands are executed in lexicographical order of their key names. Default: - Automatically generated based on index
        :param service_restart_handles: Restart the given service(s) after this command has run. Default: - Do not restart any service
        :param test_cmd: Command to determine whether this command should be run. If the test passes (exits with error code of 0), the command is run. Default: - Always run the command
        :param wait_after_completion: The duration to wait after a command has finished in case the command causes a reboot. Set this value to ``InitCommandWaitDuration.none()`` if you do not want to wait for every command; ``InitCommandWaitDuration.forever()`` directs cfn-init to exit and resume only after the reboot is complete. For Windows systems only. Default: - 60 seconds
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71ea5576b12638380fbef26e998e310527c683321807e9fe504f98321b7d6a34)
            check_type(argname="argument argv", value=argv, expected_type=type_hints["argv"])
        options = InitCommandOptions(
            cwd=cwd,
            env=env,
            ignore_errors=ignore_errors,
            key=key,
            service_restart_handles=service_restart_handles,
            test_cmd=test_cmd,
            wait_after_completion=wait_after_completion,
        )

        return typing.cast("InitCommand", jsii.sinvoke(cls, "argvCommand", [argv, options]))

    @jsii.member(jsii_name="shellCommand")
    @builtins.classmethod
    def shell_command(
        cls,
        shell_command: builtins.str,
        *,
        cwd: typing.Optional[builtins.str] = None,
        env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        ignore_errors: typing.Optional[builtins.bool] = None,
        key: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        test_cmd: typing.Optional[builtins.str] = None,
        wait_after_completion: typing.Optional[InitCommandWaitDuration] = None,
    ) -> "InitCommand":
        '''Run a shell command.

        Remember that some characters like ``&``, ``|``, ``;``, ``>`` etc. have special meaning in a shell and
        need to be preceded by a ``\\`` if you want to treat them as part of a filename.

        :param shell_command: -
        :param cwd: The working directory. Default: - Use default working directory
        :param env: Sets environment variables for the command. This property overwrites, rather than appends, the existing environment. Default: - Use current environment
        :param ignore_errors: Continue running if this command fails. Default: false
        :param key: Identifier key for this command. Commands are executed in lexicographical order of their key names. Default: - Automatically generated based on index
        :param service_restart_handles: Restart the given service(s) after this command has run. Default: - Do not restart any service
        :param test_cmd: Command to determine whether this command should be run. If the test passes (exits with error code of 0), the command is run. Default: - Always run the command
        :param wait_after_completion: The duration to wait after a command has finished in case the command causes a reboot. Set this value to ``InitCommandWaitDuration.none()`` if you do not want to wait for every command; ``InitCommandWaitDuration.forever()`` directs cfn-init to exit and resume only after the reboot is complete. For Windows systems only. Default: - 60 seconds
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fda781af7564e97061c3e86997ea287b99b8f620f6e62f1c8083fbd3f3244474)
            check_type(argname="argument shell_command", value=shell_command, expected_type=type_hints["shell_command"])
        options = InitCommandOptions(
            cwd=cwd,
            env=env,
            ignore_errors=ignore_errors,
            key=key,
            service_restart_handles=service_restart_handles,
            test_cmd=test_cmd,
            wait_after_completion=wait_after_completion,
        )

        return typing.cast("InitCommand", jsii.sinvoke(cls, "shellCommand", [shell_command, options]))

    @builtins.property
    @jsii.member(jsii_name="elementType")
    def element_type(self) -> builtins.str:
        '''Returns the init element type for this element.'''
        return typing.cast(builtins.str, jsii.get(self, "elementType"))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitFileAssetOptions",
    jsii_struct_bases=[InitFileOptions, _AssetOptions_2aa69621],
    name_mapping={
        "base64_encoded": "base64Encoded",
        "group": "group",
        "mode": "mode",
        "owner": "owner",
        "service_restart_handles": "serviceRestartHandles",
        "asset_hash": "assetHash",
        "asset_hash_type": "assetHashType",
        "bundling": "bundling",
        "exclude": "exclude",
        "follow_symlinks": "followSymlinks",
        "ignore_mode": "ignoreMode",
        "deploy_time": "deployTime",
        "readers": "readers",
    },
)
class InitFileAssetOptions(InitFileOptions, _AssetOptions_2aa69621):
    def __init__(
        self,
        *,
        base64_encoded: typing.Optional[builtins.bool] = None,
        group: typing.Optional[builtins.str] = None,
        mode: typing.Optional[builtins.str] = None,
        owner: typing.Optional[builtins.str] = None,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        asset_hash: typing.Optional[builtins.str] = None,
        asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
        bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
        follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
        ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
        deploy_time: typing.Optional[builtins.bool] = None,
        readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
    ) -> None:
        '''Additional options for creating an InitFile from an asset.

        :param base64_encoded: True if the inlined content (from a string or file) should be treated as base64 encoded. Only applicable for inlined string and file content. Default: false
        :param group: The name of the owning group for this file. Not supported for Windows systems. Default: 'root'
        :param mode: A six-digit octal value representing the mode for this file. Use the first three digits for symlinks and the last three digits for setting permissions. To create a symlink, specify 120xxx, where xxx defines the permissions of the target file. To specify permissions for a file, use the last three digits, such as 000644. Not supported for Windows systems. Default: '000644'
        :param owner: The name of the owning user for this file. Not supported for Windows systems. Default: 'root'
        :param service_restart_handles: Restart the given service after this file has been written. Default: - Do not restart any service
        :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
        :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
        :param exclude: File paths matching the patterns will be excluded. See ``ignoreMode`` to set the matching behavior. Has no effect on Assets bundled using the ``bundling`` property. Default: - nothing is excluded
        :param follow_symlinks: A strategy for how to handle symlinks. Default: SymlinkFollowMode.NEVER
        :param ignore_mode: The ignore behavior to use for ``exclude`` patterns. Default: IgnoreMode.GLOB
        :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
        :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_iam as iam
            
            # docker_image: cdk.DockerImage
            # grantable: iam.IGrantable
            # init_service_restart_handle: ec2.InitServiceRestartHandle
            # local_bundling: cdk.ILocalBundling
            
            init_file_asset_options = ec2.InitFileAssetOptions(
                asset_hash="assetHash",
                asset_hash_type=cdk.AssetHashType.SOURCE,
                base64_encoded=False,
                bundling=cdk.BundlingOptions(
                    image=docker_image,
            
                    # the properties below are optional
                    bundling_file_access=cdk.BundlingFileAccess.VOLUME_COPY,
                    command=["command"],
                    entrypoint=["entrypoint"],
                    environment={
                        "environment_key": "environment"
                    },
                    local=local_bundling,
                    network="network",
                    output_type=cdk.BundlingOutput.ARCHIVED,
                    platform="platform",
                    security_opt="securityOpt",
                    user="user",
                    volumes=[cdk.DockerVolume(
                        container_path="containerPath",
                        host_path="hostPath",
            
                        # the properties below are optional
                        consistency=cdk.DockerVolumeConsistency.CONSISTENT
                    )],
                    volumes_from=["volumesFrom"],
                    working_directory="workingDirectory"
                ),
                deploy_time=False,
                exclude=["exclude"],
                follow_symlinks=cdk.SymlinkFollowMode.NEVER,
                group="group",
                ignore_mode=cdk.IgnoreMode.GLOB,
                mode="mode",
                owner="owner",
                readers=[grantable],
                service_restart_handles=[init_service_restart_handle]
            )
        '''
        if isinstance(bundling, dict):
            bundling = _BundlingOptions_588cc936(**bundling)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ce391dd6a64744f1d308a93bd2b78efee46c104a775f9153a5171d8a73909fd)
            check_type(argname="argument base64_encoded", value=base64_encoded, expected_type=type_hints["base64_encoded"])
            check_type(argname="argument group", value=group, expected_type=type_hints["group"])
            check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
            check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
            check_type(argname="argument asset_hash", value=asset_hash, expected_type=type_hints["asset_hash"])
            check_type(argname="argument asset_hash_type", value=asset_hash_type, expected_type=type_hints["asset_hash_type"])
            check_type(argname="argument bundling", value=bundling, expected_type=type_hints["bundling"])
            check_type(argname="argument exclude", value=exclude, expected_type=type_hints["exclude"])
            check_type(argname="argument follow_symlinks", value=follow_symlinks, expected_type=type_hints["follow_symlinks"])
            check_type(argname="argument ignore_mode", value=ignore_mode, expected_type=type_hints["ignore_mode"])
            check_type(argname="argument deploy_time", value=deploy_time, expected_type=type_hints["deploy_time"])
            check_type(argname="argument readers", value=readers, expected_type=type_hints["readers"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if base64_encoded is not None:
            self._values["base64_encoded"] = base64_encoded
        if group is not None:
            self._values["group"] = group
        if mode is not None:
            self._values["mode"] = mode
        if owner is not None:
            self._values["owner"] = owner
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles
        if asset_hash is not None:
            self._values["asset_hash"] = asset_hash
        if asset_hash_type is not None:
            self._values["asset_hash_type"] = asset_hash_type
        if bundling is not None:
            self._values["bundling"] = bundling
        if exclude is not None:
            self._values["exclude"] = exclude
        if follow_symlinks is not None:
            self._values["follow_symlinks"] = follow_symlinks
        if ignore_mode is not None:
            self._values["ignore_mode"] = ignore_mode
        if deploy_time is not None:
            self._values["deploy_time"] = deploy_time
        if readers is not None:
            self._values["readers"] = readers

    @builtins.property
    def base64_encoded(self) -> typing.Optional[builtins.bool]:
        '''True if the inlined content (from a string or file) should be treated as base64 encoded.

        Only applicable for inlined string and file content.

        :default: false
        '''
        result = self._values.get("base64_encoded")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def group(self) -> typing.Optional[builtins.str]:
        '''The name of the owning group for this file.

        Not supported for Windows systems.

        :default: 'root'
        '''
        result = self._values.get("group")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def mode(self) -> typing.Optional[builtins.str]:
        '''A six-digit octal value representing the mode for this file.

        Use the first three digits for symlinks and the last three digits for
        setting permissions. To create a symlink, specify 120xxx, where xxx
        defines the permissions of the target file. To specify permissions for a
        file, use the last three digits, such as 000644.

        Not supported for Windows systems.

        :default: '000644'
        '''
        result = self._values.get("mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def owner(self) -> typing.Optional[builtins.str]:
        '''The name of the owning user for this file.

        Not supported for Windows systems.

        :default: 'root'
        '''
        result = self._values.get("owner")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List[InitServiceRestartHandle]]:
        '''Restart the given service after this file has been written.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List[InitServiceRestartHandle]], result)

    @builtins.property
    def asset_hash(self) -> typing.Optional[builtins.str]:
        '''Specify a custom hash for this asset.

        If ``assetHashType`` is set it must
        be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will
        be SHA256 hashed and encoded as hex. The resulting hash will be the asset
        hash.

        NOTE: the hash is used in order to identify a specific revision of the asset, and
        used for optimizing and caching deployment activities related to this asset such as
        packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will
        need to make sure it is updated every time the asset changes, or otherwise it is
        possible that some deployments will not be invalidated.

        :default: - based on ``assetHashType``
        '''
        result = self._values.get("asset_hash")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def asset_hash_type(self) -> typing.Optional[_AssetHashType_05b67f2d]:
        '''Specifies the type of hash to calculate for this asset.

        If ``assetHash`` is configured, this option must be ``undefined`` or
        ``AssetHashType.CUSTOM``.

        :default:

        - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is
        explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        '''
        result = self._values.get("asset_hash_type")
        return typing.cast(typing.Optional[_AssetHashType_05b67f2d], result)

    @builtins.property
    def bundling(self) -> typing.Optional[_BundlingOptions_588cc936]:
        '''Bundle the asset by executing a command in a Docker container or a custom bundling provider.

        The asset path will be mounted at ``/asset-input``. The Docker
        container is responsible for putting content at ``/asset-output``.
        The content at ``/asset-output`` will be zipped and used as the
        final asset.

        :default:

        - uploaded as-is to S3 if the asset is a regular file or a .zip file,
        archived into a .zip file and uploaded to S3 otherwise
        '''
        result = self._values.get("bundling")
        return typing.cast(typing.Optional[_BundlingOptions_588cc936], result)

    @builtins.property
    def exclude(self) -> typing.Optional[typing.List[builtins.str]]:
        '''File paths matching the patterns will be excluded.

        See ``ignoreMode`` to set the matching behavior.
        Has no effect on Assets bundled using the ``bundling`` property.

        :default: - nothing is excluded
        '''
        result = self._values.get("exclude")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def follow_symlinks(self) -> typing.Optional[_SymlinkFollowMode_047ec1f6]:
        '''A strategy for how to handle symlinks.

        :default: SymlinkFollowMode.NEVER
        '''
        result = self._values.get("follow_symlinks")
        return typing.cast(typing.Optional[_SymlinkFollowMode_047ec1f6], result)

    @builtins.property
    def ignore_mode(self) -> typing.Optional[_IgnoreMode_655a98e8]:
        '''The ignore behavior to use for ``exclude`` patterns.

        :default: IgnoreMode.GLOB
        '''
        result = self._values.get("ignore_mode")
        return typing.cast(typing.Optional[_IgnoreMode_655a98e8], result)

    @builtins.property
    def deploy_time(self) -> typing.Optional[builtins.bool]:
        '''Whether or not the asset needs to exist beyond deployment time;

        i.e.
        are copied over to a different location and not needed afterwards.
        Setting this property to true has an impact on the lifecycle of the asset,
        because we will assume that it is safe to delete after the CloudFormation
        deployment succeeds.

        For example, Lambda Function assets are copied over to Lambda during
        deployment. Therefore, it is not necessary to store the asset in S3, so
        we consider those deployTime assets.

        :default: false
        '''
        result = self._values.get("deploy_time")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def readers(self) -> typing.Optional[typing.List[_IGrantable_71c4f5de]]:
        '''A list of principals that should be able to read this asset from S3.

        You can use ``asset.grantRead(principal)`` to grant read permissions later.

        :default: - No principals that can read file asset.
        '''
        result = self._values.get("readers")
        return typing.cast(typing.Optional[typing.List[_IGrantable_71c4f5de]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitFileAssetOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.InitSourceAssetOptions",
    jsii_struct_bases=[InitSourceOptions, _AssetOptions_2aa69621],
    name_mapping={
        "service_restart_handles": "serviceRestartHandles",
        "asset_hash": "assetHash",
        "asset_hash_type": "assetHashType",
        "bundling": "bundling",
        "exclude": "exclude",
        "follow_symlinks": "followSymlinks",
        "ignore_mode": "ignoreMode",
        "deploy_time": "deployTime",
        "readers": "readers",
    },
)
class InitSourceAssetOptions(InitSourceOptions, _AssetOptions_2aa69621):
    def __init__(
        self,
        *,
        service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
        asset_hash: typing.Optional[builtins.str] = None,
        asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
        bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
        follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
        ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
        deploy_time: typing.Optional[builtins.bool] = None,
        readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
    ) -> None:
        '''Additional options for an InitSource that builds an asset from local files.

        :param service_restart_handles: Restart the given services after this archive has been extracted. Default: - Do not restart any service
        :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
        :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
        :param exclude: File paths matching the patterns will be excluded. See ``ignoreMode`` to set the matching behavior. Has no effect on Assets bundled using the ``bundling`` property. Default: - nothing is excluded
        :param follow_symlinks: A strategy for how to handle symlinks. Default: SymlinkFollowMode.NEVER
        :param ignore_mode: The ignore behavior to use for ``exclude`` patterns. Default: IgnoreMode.GLOB
        :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
        :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            import aws_cdk as cdk
            from aws_cdk import aws_ec2 as ec2
            from aws_cdk import aws_iam as iam
            
            # docker_image: cdk.DockerImage
            # grantable: iam.IGrantable
            # init_service_restart_handle: ec2.InitServiceRestartHandle
            # local_bundling: cdk.ILocalBundling
            
            init_source_asset_options = ec2.InitSourceAssetOptions(
                asset_hash="assetHash",
                asset_hash_type=cdk.AssetHashType.SOURCE,
                bundling=cdk.BundlingOptions(
                    image=docker_image,
            
                    # the properties below are optional
                    bundling_file_access=cdk.BundlingFileAccess.VOLUME_COPY,
                    command=["command"],
                    entrypoint=["entrypoint"],
                    environment={
                        "environment_key": "environment"
                    },
                    local=local_bundling,
                    network="network",
                    output_type=cdk.BundlingOutput.ARCHIVED,
                    platform="platform",
                    security_opt="securityOpt",
                    user="user",
                    volumes=[cdk.DockerVolume(
                        container_path="containerPath",
                        host_path="hostPath",
            
                        # the properties below are optional
                        consistency=cdk.DockerVolumeConsistency.CONSISTENT
                    )],
                    volumes_from=["volumesFrom"],
                    working_directory="workingDirectory"
                ),
                deploy_time=False,
                exclude=["exclude"],
                follow_symlinks=cdk.SymlinkFollowMode.NEVER,
                ignore_mode=cdk.IgnoreMode.GLOB,
                readers=[grantable],
                service_restart_handles=[init_service_restart_handle]
            )
        '''
        if isinstance(bundling, dict):
            bundling = _BundlingOptions_588cc936(**bundling)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3d9778b6f3d55d750d385b361f8381c51ee484d3c8920175605233fbe5f951c)
            check_type(argname="argument service_restart_handles", value=service_restart_handles, expected_type=type_hints["service_restart_handles"])
            check_type(argname="argument asset_hash", value=asset_hash, expected_type=type_hints["asset_hash"])
            check_type(argname="argument asset_hash_type", value=asset_hash_type, expected_type=type_hints["asset_hash_type"])
            check_type(argname="argument bundling", value=bundling, expected_type=type_hints["bundling"])
            check_type(argname="argument exclude", value=exclude, expected_type=type_hints["exclude"])
            check_type(argname="argument follow_symlinks", value=follow_symlinks, expected_type=type_hints["follow_symlinks"])
            check_type(argname="argument ignore_mode", value=ignore_mode, expected_type=type_hints["ignore_mode"])
            check_type(argname="argument deploy_time", value=deploy_time, expected_type=type_hints["deploy_time"])
            check_type(argname="argument readers", value=readers, expected_type=type_hints["readers"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if service_restart_handles is not None:
            self._values["service_restart_handles"] = service_restart_handles
        if asset_hash is not None:
            self._values["asset_hash"] = asset_hash
        if asset_hash_type is not None:
            self._values["asset_hash_type"] = asset_hash_type
        if bundling is not None:
            self._values["bundling"] = bundling
        if exclude is not None:
            self._values["exclude"] = exclude
        if follow_symlinks is not None:
            self._values["follow_symlinks"] = follow_symlinks
        if ignore_mode is not None:
            self._values["ignore_mode"] = ignore_mode
        if deploy_time is not None:
            self._values["deploy_time"] = deploy_time
        if readers is not None:
            self._values["readers"] = readers

    @builtins.property
    def service_restart_handles(
        self,
    ) -> typing.Optional[typing.List[InitServiceRestartHandle]]:
        '''Restart the given services after this archive has been extracted.

        :default: - Do not restart any service
        '''
        result = self._values.get("service_restart_handles")
        return typing.cast(typing.Optional[typing.List[InitServiceRestartHandle]], result)

    @builtins.property
    def asset_hash(self) -> typing.Optional[builtins.str]:
        '''Specify a custom hash for this asset.

        If ``assetHashType`` is set it must
        be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will
        be SHA256 hashed and encoded as hex. The resulting hash will be the asset
        hash.

        NOTE: the hash is used in order to identify a specific revision of the asset, and
        used for optimizing and caching deployment activities related to this asset such as
        packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will
        need to make sure it is updated every time the asset changes, or otherwise it is
        possible that some deployments will not be invalidated.

        :default: - based on ``assetHashType``
        '''
        result = self._values.get("asset_hash")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def asset_hash_type(self) -> typing.Optional[_AssetHashType_05b67f2d]:
        '''Specifies the type of hash to calculate for this asset.

        If ``assetHash`` is configured, this option must be ``undefined`` or
        ``AssetHashType.CUSTOM``.

        :default:

        - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is
        explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
        '''
        result = self._values.get("asset_hash_type")
        return typing.cast(typing.Optional[_AssetHashType_05b67f2d], result)

    @builtins.property
    def bundling(self) -> typing.Optional[_BundlingOptions_588cc936]:
        '''Bundle the asset by executing a command in a Docker container or a custom bundling provider.

        The asset path will be mounted at ``/asset-input``. The Docker
        container is responsible for putting content at ``/asset-output``.
        The content at ``/asset-output`` will be zipped and used as the
        final asset.

        :default:

        - uploaded as-is to S3 if the asset is a regular file or a .zip file,
        archived into a .zip file and uploaded to S3 otherwise
        '''
        result = self._values.get("bundling")
        return typing.cast(typing.Optional[_BundlingOptions_588cc936], result)

    @builtins.property
    def exclude(self) -> typing.Optional[typing.List[builtins.str]]:
        '''File paths matching the patterns will be excluded.

        See ``ignoreMode`` to set the matching behavior.
        Has no effect on Assets bundled using the ``bundling`` property.

        :default: - nothing is excluded
        '''
        result = self._values.get("exclude")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def follow_symlinks(self) -> typing.Optional[_SymlinkFollowMode_047ec1f6]:
        '''A strategy for how to handle symlinks.

        :default: SymlinkFollowMode.NEVER
        '''
        result = self._values.get("follow_symlinks")
        return typing.cast(typing.Optional[_SymlinkFollowMode_047ec1f6], result)

    @builtins.property
    def ignore_mode(self) -> typing.Optional[_IgnoreMode_655a98e8]:
        '''The ignore behavior to use for ``exclude`` patterns.

        :default: IgnoreMode.GLOB
        '''
        result = self._values.get("ignore_mode")
        return typing.cast(typing.Optional[_IgnoreMode_655a98e8], result)

    @builtins.property
    def deploy_time(self) -> typing.Optional[builtins.bool]:
        '''Whether or not the asset needs to exist beyond deployment time;

        i.e.
        are copied over to a different location and not needed afterwards.
        Setting this property to true has an impact on the lifecycle of the asset,
        because we will assume that it is safe to delete after the CloudFormation
        deployment succeeds.

        For example, Lambda Function assets are copied over to Lambda during
        deployment. Therefore, it is not necessary to store the asset in S3, so
        we consider those deployTime assets.

        :default: false
        '''
        result = self._values.get("deploy_time")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def readers(self) -> typing.Optional[typing.List[_IGrantable_71c4f5de]]:
        '''A list of principals that should be able to read this asset from S3.

        You can use ``asset.grantRead(principal)`` to grant read permissions later.

        :default: - No principals that can read file asset.
        '''
        result = self._values.get("readers")
        return typing.cast(typing.Optional[typing.List[_IGrantable_71c4f5de]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InitSourceAssetOptions(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IInterfaceVpcEndpoint)
class InterfaceVpcEndpoint(
    VpcEndpoint,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.InterfaceVpcEndpoint",
):
    '''A interface VPC endpoint.

    :resource: AWS::EC2::VPCEndpoint
    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        ec2.InterfaceVpcEndpoint(self, "VPC Endpoint",
            vpc=vpc,
            service=ec2.InterfaceVpcEndpointService("com.amazonaws.vpce.us-east-1.vpce-svc-uuddlrlrbastrtsvc", 443),
            # Choose which availability zones to place the VPC endpoint in, based on
            # available AZs
            subnets=ec2.SubnetSelection(
                availability_zones=["us-east-1a", "us-east-1c"]
            )
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        service: IInterfaceVpcEndpointService,
        lookup_supported_azs: typing.Optional[builtins.bool] = None,
        open: typing.Optional[builtins.bool] = None,
        private_dns_enabled: typing.Optional[builtins.bool] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC network in which the interface endpoint will be used.
        :param service: The service to use for this interface VPC endpoint.
        :param lookup_supported_azs: Limit to only those availability zones where the endpoint service can be created. Setting this to 'true' requires a lookup to be performed at synthesis time. Account and region must be set on the containing stack for this to work. Default: false
        :param open: Whether to automatically allow VPC traffic to the endpoint. If enabled, all traffic to the endpoint from within the VPC will be automatically allowed. This is done based on the VPC's CIDR range. Default: true
        :param private_dns_enabled: Whether to associate a private hosted zone with the specified VPC. This allows you to make requests to the service using its default DNS hostname. Default: set by the instance of IInterfaceVpcEndpointService, or true if not defined by the instance of IInterfaceVpcEndpointService
        :param security_groups: The security groups to associate with this interface VPC endpoint. Default: - a new security group is created
        :param subnets: The subnets in which to create an endpoint network interface. At most one per availability zone. Default: - private subnets
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a11756d82f1033710d89b4b10b111462f7a99734ff79d3648bd84d0e57ff3dc9)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = InterfaceVpcEndpointProps(
            vpc=vpc,
            service=service,
            lookup_supported_azs=lookup_supported_azs,
            open=open,
            private_dns_enabled=private_dns_enabled,
            security_groups=security_groups,
            subnets=subnets,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromInterfaceVpcEndpointAttributes")
    @builtins.classmethod
    def from_interface_vpc_endpoint_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        port: jsii.Number,
        vpc_endpoint_id: builtins.str,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    ) -> IInterfaceVpcEndpoint:
        '''Imports an existing interface VPC endpoint.

        :param scope: -
        :param id: -
        :param port: The port of the service of the interface VPC endpoint.
        :param vpc_endpoint_id: The interface VPC endpoint identifier.
        :param security_groups: The security groups associated with the interface VPC endpoint. If you wish to manage the network connections associated with this endpoint, you will need to specify its security groups.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e163a4ca85dcc83e205f6b431d2755dd7741f92d4c17f842dec2ef54393db5ed)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = InterfaceVpcEndpointAttributes(
            port=port, vpc_endpoint_id=vpc_endpoint_id, security_groups=security_groups
        )

        return typing.cast(IInterfaceVpcEndpoint, jsii.sinvoke(cls, "fromInterfaceVpcEndpointAttributes", [scope, id, attrs]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> Connections:
        '''Access to network connections.'''
        return typing.cast(Connections, jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointCreationTimestamp")
    def vpc_endpoint_creation_timestamp(self) -> builtins.str:
        '''The date and time the interface VPC endpoint was created.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointCreationTimestamp"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointDnsEntries")
    def vpc_endpoint_dns_entries(self) -> typing.List[builtins.str]:
        '''The DNS entries for the interface VPC endpoint.

        Each entry is a combination of the hosted zone ID and the DNS name.
        The entries are ordered as follows: regional public DNS, zonal public DNS, private DNS, and wildcard DNS.
        This order is not enforced for AWS Marketplace services.

        The following is an example. In the first entry, the hosted zone ID is Z1HUB23UULQXV
        and the DNS name is vpce-01abc23456de78f9g-12abccd3.ec2.us-east-1.vpce.amazonaws.com.

        ["Z1HUB23UULQXV:vpce-01abc23456de78f9g-12abccd3.ec2.us-east-1.vpce.amazonaws.com",
        "Z1HUB23UULQXV:vpce-01abc23456de78f9g-12abccd3-us-east-1a.ec2.us-east-1.vpce.amazonaws.com",
        "Z1C12344VYDITB0:ec2.us-east-1.amazonaws.com"]

        If you update the PrivateDnsEnabled or SubnetIds properties, the DNS entries in the list will change.

        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcEndpointDnsEntries"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> builtins.str:
        '''The interface VPC endpoint identifier.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointId"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointNetworkInterfaceIds")
    def vpc_endpoint_network_interface_ids(self) -> typing.List[builtins.str]:
        '''One or more network interfaces for the interface VPC endpoint.

        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcEndpointNetworkInterfaceIds"))


class MultipartUserData(
    UserData,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.MultipartUserData",
):
    '''Mime multipart user data.

    This class represents MIME multipart user data, as described in.
    `Specifying Multiple User Data Blocks Using a MIME Multi Part Archive <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#multi-part_user_data>`_

    :exampleMetadata: infused

    Example::

        boot_hook_conf = ec2.UserData.for_linux()
        boot_hook_conf.add_commands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker")
        
        setup_commands = ec2.UserData.for_linux()
        setup_commands.add_commands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup")
        
        multipart_user_data = ec2.MultipartUserData()
        # The docker has to be configured at early stage, so content type is overridden to boothook
        multipart_user_data.add_part(ec2.MultipartBody.from_user_data(boot_hook_conf, "text/cloud-boothook; charset=\"us-ascii\""))
        # Execute the rest of setup
        multipart_user_data.add_part(ec2.MultipartBody.from_user_data(setup_commands))
        
        ec2.LaunchTemplate(self, "",
            user_data=multipart_user_data,
            block_devices=[]
        )
    '''

    def __init__(
        self,
        *,
        parts_separator: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param parts_separator: The string used to separate parts in multipart user data archive (it's like MIME boundary). This string should contain [a-zA-Z0-9()+,-./:=?] characters only, and should not be present in any part, or in text content of archive. Default: ``+AWS+CDK+User+Data+Separator==``
        '''
        opts = MultipartUserDataOptions(parts_separator=parts_separator)

        jsii.create(self.__class__, self, [opts])

    @jsii.member(jsii_name="addCommands")
    def add_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data.

        :param commands: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5987dcbb14ba167119476888ad874e6cdde3a391dfbf6722d7c4a33f74f670c8)
            check_type(argname="argument commands", value=commands, expected_type=typing.Tuple[type_hints["commands"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addCommands", [*commands]))

    @jsii.member(jsii_name="addExecuteFileCommand")
    def add_execute_file_command(
        self,
        *,
        file_path: builtins.str,
        arguments: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Adds commands to execute a file.

        :param file_path: The path to the file.
        :param arguments: The arguments to be passed to the file. Default: No arguments are passed to the file.
        '''
        params = ExecuteFileOptions(file_path=file_path, arguments=arguments)

        return typing.cast(None, jsii.invoke(self, "addExecuteFileCommand", [params]))

    @jsii.member(jsii_name="addOnExitCommands")
    def add_on_exit_commands(self, *commands: builtins.str) -> None:
        '''Add one or more commands to the user data that will run when the script exits.

        :param commands: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c3b0dbc14c83a0fe273524a287d6117b26bea3d9b86673eedaf99be6f3f4bda4)
            check_type(argname="argument commands", value=commands, expected_type=typing.Tuple[type_hints["commands"], ...]) # pyright: ignore [reportGeneralTypeIssues]
        return typing.cast(None, jsii.invoke(self, "addOnExitCommands", [*commands]))

    @jsii.member(jsii_name="addPart")
    def add_part(self, part: MultipartBody) -> None:
        '''Adds a part to the list of parts.

        :param part: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9ce752ae4645726bf7e35d37d33fed54a1d1c358bcbedfc878fb63e7fd48b4ac)
            check_type(argname="argument part", value=part, expected_type=type_hints["part"])
        return typing.cast(None, jsii.invoke(self, "addPart", [part]))

    @jsii.member(jsii_name="addS3DownloadCommand")
    def add_s3_download_command(
        self,
        *,
        bucket: _IBucket_42e086fd,
        bucket_key: builtins.str,
        local_file: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''Adds commands to download a file from S3.

        :param bucket: Name of the S3 bucket to download from.
        :param bucket_key: The key of the file to download.
        :param local_file: The name of the local file. Default: Linux - /tmp/bucketKey Windows - %TEMP%/bucketKey
        :param region: The region of the S3 Bucket (needed for access via VPC Gateway). Default: none
        '''
        params = S3DownloadOptions(
            bucket=bucket, bucket_key=bucket_key, local_file=local_file, region=region
        )

        return typing.cast(builtins.str, jsii.invoke(self, "addS3DownloadCommand", [params]))

    @jsii.member(jsii_name="addSignalOnExitCommand")
    def add_signal_on_exit_command(self, resource: _Resource_45bc6135) -> None:
        '''Adds a command which will send a cfn-signal when the user data script ends.

        :param resource: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d12d04d41d5118f934735520c298dd9660e65b22bea96d3ddba69e0a44032da8)
            check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
        return typing.cast(None, jsii.invoke(self, "addSignalOnExitCommand", [resource]))

    @jsii.member(jsii_name="addUserDataPart")
    def add_user_data_part(
        self,
        user_data: UserData,
        content_type: typing.Optional[builtins.str] = None,
        make_default: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''Adds a multipart part based on a UserData object.

        If ``makeDefault`` is true, then the UserData added by this method
        will also be the target of calls to the ``add*Command`` methods on
        this MultipartUserData object.

        If ``makeDefault`` is false, then this is the same as calling::

           # multi_part: ec2.MultipartUserData
           # user_data: ec2.UserData
           # content_type: str


           multi_part.add_part(ec2.MultipartBody.from_user_data(user_data, content_type))

        An undefined ``makeDefault`` defaults to either:

        - ``true`` if no default UserData has been set yet; or
        - ``false`` if there is no default UserData set.

        :param user_data: -
        :param content_type: -
        :param make_default: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d7099fb74981d61c8dfdb2cc1b9c36254deb6f003b7e88f104b7a0a351f31e91)
            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
            check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
            check_type(argname="argument make_default", value=make_default, expected_type=type_hints["make_default"])
        return typing.cast(None, jsii.invoke(self, "addUserDataPart", [user_data, content_type, make_default]))

    @jsii.member(jsii_name="render")
    def render(self) -> builtins.str:
        '''Render the UserData for use in a construct.'''
        return typing.cast(builtins.str, jsii.invoke(self, "render", []))


@jsii.implements(IConnectable)
class NatInstanceProvider(
    NatProvider,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.NatInstanceProvider",
):
    '''NAT provider which uses NAT Instances.

    :exampleMetadata: lit=aws-ec2/test/integ.nat-instances.lit.ts infused

    Example::

        # Configure the `natGatewayProvider` when defining a Vpc
        nat_gateway_provider = ec2.NatProvider.instance(
            instance_type=ec2.InstanceType("t3.small")
        )
        
        vpc = ec2.Vpc(self, "MyVpc",
            nat_gateway_provider=nat_gateway_provider,
        
            # The 'natGateways' parameter now controls the number of NAT instances
            nat_gateways=2
        )
    '''

    def __init__(
        self,
        *,
        instance_type: InstanceType,
        default_allowed_traffic: typing.Optional[NatTrafficDirection] = None,
        key_name: typing.Optional[builtins.str] = None,
        key_pair: typing.Optional[IKeyPair] = None,
        machine_image: typing.Optional[IMachineImage] = None,
        security_group: typing.Optional[ISecurityGroup] = None,
    ) -> None:
        '''
        :param instance_type: Instance type of the NAT instance.
        :param default_allowed_traffic: Direction to allow all traffic through the NAT instance by default. By default, inbound and outbound traffic is allowed. If you set this to another value than INBOUND_AND_OUTBOUND, you must configure the NAT instance's security groups in another way, either by passing in a fully configured Security Group using the ``securityGroup`` property, or by configuring it using the ``.securityGroup`` or ``.connections`` members after passing the NAT Instance Provider to a Vpc. Default: NatTrafficDirection.INBOUND_AND_OUTBOUND
        :param key_name: (deprecated) Name of SSH keypair to grant access to instance. Default: - No SSH access will be possible.
        :param key_pair: The SSH keypair to grant access to the instance. Default: - No SSH access will be possible.
        :param machine_image: The machine image (AMI) to use. By default, will do an AMI lookup for the latest NAT instance image. If you have a specific AMI ID you want to use, pass a ``GenericLinuxImage``. For example:: ec2.NatProvider.instance({ instanceType: new ec2.InstanceType('t3.micro'), machineImage: new ec2.GenericLinuxImage({ 'us-east-2': 'ami-0f9c61b5a562a16af' }) }) Default: - Latest NAT instance image
        :param security_group: Security Group for NAT instances. Default: - A new security group will be created
        '''
        props = NatInstanceProps(
            instance_type=instance_type,
            default_allowed_traffic=default_allowed_traffic,
            key_name=key_name,
            key_pair=key_pair,
            machine_image=machine_image,
            security_group=security_group,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="configureNat")
    def configure_nat(
        self,
        *,
        nat_subnets: typing.Sequence["PublicSubnet"],
        private_subnets: typing.Sequence["PrivateSubnet"],
        vpc: Vpc,
    ) -> None:
        '''Called by the VPC to configure NAT.

        Don't call this directly, the VPC will call it automatically.

        :param nat_subnets: The public subnets where the NAT providers need to be placed.
        :param private_subnets: The private subnets that need to route through the NAT providers. There may be more private subnets than public subnets with NAT providers.
        :param vpc: The VPC we're configuring NAT for.
        '''
        options = ConfigureNatOptions(
            nat_subnets=nat_subnets, private_subnets=private_subnets, vpc=vpc
        )

        return typing.cast(None, jsii.invoke(self, "configureNat", [options]))

    @jsii.member(jsii_name="configureSubnet")
    def configure_subnet(self, subnet: "PrivateSubnet") -> None:
        '''Configures subnet with the gateway.

        Don't call this directly, the VPC will call it automatically.

        :param subnet: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53772cd5bc705ccbd691b4063a85c8427a71a5c9fc29d3af5c0a334c7df3f57a)
            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
        return typing.cast(None, jsii.invoke(self, "configureSubnet", [subnet]))

    @builtins.property
    @jsii.member(jsii_name="configuredGateways")
    def configured_gateways(self) -> typing.List[GatewayConfig]:
        '''Return list of gateways spawned by the provider.'''
        return typing.cast(typing.List[GatewayConfig], jsii.get(self, "configuredGateways"))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> Connections:
        '''Manage the Security Groups associated with the NAT instances.'''
        return typing.cast(Connections, jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="securityGroup")
    def security_group(self) -> ISecurityGroup:
        '''The Security Group associated with the NAT instances.'''
        return typing.cast(ISecurityGroup, jsii.get(self, "securityGroup"))


@jsii.implements(IPrivateSubnet)
class PrivateSubnet(
    Subnet,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.PrivateSubnet",
):
    '''Represents a private VPC subnet resource.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        private_subnet = ec2.PrivateSubnet(self, "MyPrivateSubnet",
            availability_zone="availabilityZone",
            cidr_block="cidrBlock",
            vpc_id="vpcId",
        
            # the properties below are optional
            assign_ipv6_address_on_creation=False,
            ipv6_cidr_block="ipv6CidrBlock",
            map_public_ip_on_launch=False
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e5ebef34ffa5d07794eb4c01409ecb54f33bb1760995a5e76e0356ba24dfc061)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = PrivateSubnetProps(
            availability_zone=availability_zone,
            cidr_block=cidr_block,
            vpc_id=vpc_id,
            assign_ipv6_address_on_creation=assign_ipv6_address_on_creation,
            ipv6_cidr_block=ipv6_cidr_block,
            map_public_ip_on_launch=map_public_ip_on_launch,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromPrivateSubnetAttributes")
    @builtins.classmethod
    def from_private_subnet_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> IPrivateSubnet:
        '''
        :param scope: -
        :param id: -
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ae71ae27f87cc528aa9006d8209d459221ae5f8f2dc1bbea65ed4e53f618dd17)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = PrivateSubnetAttributes(
            subnet_id=subnet_id,
            availability_zone=availability_zone,
            ipv4_cidr_block=ipv4_cidr_block,
            route_table_id=route_table_id,
        )

        return typing.cast(IPrivateSubnet, jsii.sinvoke(cls, "fromPrivateSubnetAttributes", [scope, id, attrs]))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PrivateSubnetAttributes",
    jsii_struct_bases=[SubnetAttributes],
    name_mapping={
        "subnet_id": "subnetId",
        "availability_zone": "availabilityZone",
        "ipv4_cidr_block": "ipv4CidrBlock",
        "route_table_id": "routeTableId",
    },
)
class PrivateSubnetAttributes(SubnetAttributes):
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            private_subnet_attributes = ec2.PrivateSubnetAttributes(
                subnet_id="subnetId",
            
                # the properties below are optional
                availability_zone="availabilityZone",
                ipv4_cidr_block="ipv4CidrBlock",
                route_table_id="routeTableId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__667aaaf1a42672f1f3e305988600ce3579dbd1419c23697ce76b29e1e14dc6b7)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument ipv4_cidr_block", value=ipv4_cidr_block, expected_type=type_hints["ipv4_cidr_block"])
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if ipv4_cidr_block is not None:
            self._values["ipv4_cidr_block"] = ipv4_cidr_block
        if route_table_id is not None:
            self._values["route_table_id"] = route_table_id

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.'''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone the subnet is located in.

        :default: - No AZ information, cannot use AZ selection features
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR block associated with the subnet.

        :default: - No CIDR information, cannot use CIDR filter features
        '''
        result = self._values.get("ipv4_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the route table for this particular subnet.

        :default: - No route table information, cannot create VPC endpoints
        '''
        result = self._values.get("route_table_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PrivateSubnetAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PrivateSubnetProps",
    jsii_struct_bases=[SubnetProps],
    name_mapping={
        "availability_zone": "availabilityZone",
        "cidr_block": "cidrBlock",
        "vpc_id": "vpcId",
        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "map_public_ip_on_launch": "mapPublicIpOnLaunch",
    },
)
class PrivateSubnetProps(SubnetProps):
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            private_subnet_props = ec2.PrivateSubnetProps(
                availability_zone="availabilityZone",
                cidr_block="cidrBlock",
                vpc_id="vpcId",
            
                # the properties below are optional
                assign_ipv6_address_on_creation=False,
                ipv6_cidr_block="ipv6CidrBlock",
                map_public_ip_on_launch=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__775f73071cbd2cc2e4cf30b785aba300611f0a810ebc763fc39ebd232b031ee1)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument assign_ipv6_address_on_creation", value=assign_ipv6_address_on_creation, expected_type=type_hints["assign_ipv6_address_on_creation"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument map_public_ip_on_launch", value=map_public_ip_on_launch, expected_type=type_hints["map_public_ip_on_launch"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "cidr_block": cidr_block,
            "vpc_id": vpc_id,
        }
        if assign_ipv6_address_on_creation is not None:
            self._values["assign_ipv6_address_on_creation"] = assign_ipv6_address_on_creation
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if map_public_ip_on_launch is not None:
            self._values["map_public_ip_on_launch"] = map_public_ip_on_launch

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The availability zone for the subnet.'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr_block(self) -> builtins.str:
        '''The CIDR notation for this subnet.'''
        result = self._values.get("cidr_block")
        assert result is not None, "Required property 'cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The VPC which this subnet is part of.'''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def assign_ipv6_address_on_creation(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether a network interface created in this subnet receives an IPv6 address.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: false
        '''
        result = self._values.get("assign_ipv6_address_on_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: - no IPv6 CIDR block.
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def map_public_ip_on_launch(self) -> typing.Optional[builtins.bool]:
        '''Controls if a public IP is associated to an instance at launch.

        :default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        result = self._values.get("map_public_ip_on_launch")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PrivateSubnetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IPublicSubnet)
class PublicSubnet(
    Subnet,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.PublicSubnet",
):
    '''Represents a public VPC subnet resource.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        public_subnet = ec2.PublicSubnet(self, "MyPublicSubnet",
            availability_zone="availabilityZone",
            cidr_block="cidrBlock",
            vpc_id="vpcId",
        
            # the properties below are optional
            assign_ipv6_address_on_creation=False,
            ipv6_cidr_block="ipv6CidrBlock",
            map_public_ip_on_launch=False
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__023d0f3df05df55fb070badbc7578a4d403248f01084362270140d22d30fc43e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = PublicSubnetProps(
            availability_zone=availability_zone,
            cidr_block=cidr_block,
            vpc_id=vpc_id,
            assign_ipv6_address_on_creation=assign_ipv6_address_on_creation,
            ipv6_cidr_block=ipv6_cidr_block,
            map_public_ip_on_launch=map_public_ip_on_launch,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromPublicSubnetAttributes")
    @builtins.classmethod
    def from_public_subnet_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> IPublicSubnet:
        '''
        :param scope: -
        :param id: -
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3942619e96cf25a67385636c8f7584fbe8dc092a0ac1deaac68d355a2d7e59d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = PublicSubnetAttributes(
            subnet_id=subnet_id,
            availability_zone=availability_zone,
            ipv4_cidr_block=ipv4_cidr_block,
            route_table_id=route_table_id,
        )

        return typing.cast(IPublicSubnet, jsii.sinvoke(cls, "fromPublicSubnetAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="addNatGateway")
    def add_nat_gateway(
        self,
        eip_allocation_id: typing.Optional[builtins.str] = None,
    ) -> CfnNatGateway:
        '''Creates a new managed NAT gateway attached to this public subnet.

        Also adds the EIP for the managed NAT.

        :param eip_allocation_id: -

        :return: A ref to the the NAT Gateway ID
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__08d76813e07f02784a1108bd81a7030a5244d286c7db7897110323a0dce945bf)
            check_type(argname="argument eip_allocation_id", value=eip_allocation_id, expected_type=type_hints["eip_allocation_id"])
        return typing.cast(CfnNatGateway, jsii.invoke(self, "addNatGateway", [eip_allocation_id]))


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PublicSubnetAttributes",
    jsii_struct_bases=[SubnetAttributes],
    name_mapping={
        "subnet_id": "subnetId",
        "availability_zone": "availabilityZone",
        "ipv4_cidr_block": "ipv4CidrBlock",
        "route_table_id": "routeTableId",
    },
)
class PublicSubnetAttributes(SubnetAttributes):
    def __init__(
        self,
        *,
        subnet_id: builtins.str,
        availability_zone: typing.Optional[builtins.str] = None,
        ipv4_cidr_block: typing.Optional[builtins.str] = None,
        route_table_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param subnet_id: The subnetId for this particular subnet.
        :param availability_zone: The Availability Zone the subnet is located in. Default: - No AZ information, cannot use AZ selection features
        :param ipv4_cidr_block: The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
        :param route_table_id: The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            public_subnet_attributes = ec2.PublicSubnetAttributes(
                subnet_id="subnetId",
            
                # the properties below are optional
                availability_zone="availabilityZone",
                ipv4_cidr_block="ipv4CidrBlock",
                route_table_id="routeTableId"
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c5cbe91d2f01859af75d3a005f1c18e5cdec09db40b2eb75450b7202ccb792a6)
            check_type(argname="argument subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument ipv4_cidr_block", value=ipv4_cidr_block, expected_type=type_hints["ipv4_cidr_block"])
            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "subnet_id": subnet_id,
        }
        if availability_zone is not None:
            self._values["availability_zone"] = availability_zone
        if ipv4_cidr_block is not None:
            self._values["ipv4_cidr_block"] = ipv4_cidr_block
        if route_table_id is not None:
            self._values["route_table_id"] = route_table_id

    @builtins.property
    def subnet_id(self) -> builtins.str:
        '''The subnetId for this particular subnet.'''
        result = self._values.get("subnet_id")
        assert result is not None, "Required property 'subnet_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def availability_zone(self) -> typing.Optional[builtins.str]:
        '''The Availability Zone the subnet is located in.

        :default: - No AZ information, cannot use AZ selection features
        '''
        result = self._values.get("availability_zone")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def ipv4_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv4 CIDR block associated with the subnet.

        :default: - No CIDR information, cannot use CIDR filter features
        '''
        result = self._values.get("ipv4_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def route_table_id(self) -> typing.Optional[builtins.str]:
        '''The ID of the route table for this particular subnet.

        :default: - No route table information, cannot create VPC endpoints
        '''
        result = self._values.get("route_table_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PublicSubnetAttributes(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="aws-cdk-lib.aws_ec2.PublicSubnetProps",
    jsii_struct_bases=[SubnetProps],
    name_mapping={
        "availability_zone": "availabilityZone",
        "cidr_block": "cidrBlock",
        "vpc_id": "vpcId",
        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
        "ipv6_cidr_block": "ipv6CidrBlock",
        "map_public_ip_on_launch": "mapPublicIpOnLaunch",
    },
)
class PublicSubnetProps(SubnetProps):
    def __init__(
        self,
        *,
        availability_zone: builtins.str,
        cidr_block: builtins.str,
        vpc_id: builtins.str,
        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
        ipv6_cidr_block: typing.Optional[builtins.str] = None,
        map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param availability_zone: The availability zone for the subnet.
        :param cidr_block: The CIDR notation for this subnet.
        :param vpc_id: The VPC which this subnet is part of.
        :param assign_ipv6_address_on_creation: Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: false
        :param ipv6_cidr_block: The IPv6 CIDR block. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - no IPv6 CIDR block.
        :param map_public_ip_on_launch: Controls if a public IP is associated to an instance at launch. Default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.

        :exampleMetadata: fixture=_generated

        Example::

            # The code below shows an example of how to instantiate this type.
            # The values are placeholders you should change.
            from aws_cdk import aws_ec2 as ec2
            
            public_subnet_props = ec2.PublicSubnetProps(
                availability_zone="availabilityZone",
                cidr_block="cidrBlock",
                vpc_id="vpcId",
            
                # the properties below are optional
                assign_ipv6_address_on_creation=False,
                ipv6_cidr_block="ipv6CidrBlock",
                map_public_ip_on_launch=False
            )
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__793cfb4a0cea65797b37d783560d33becbf8df2c9ffa83316226563a465fd0a3)
            check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
            check_type(argname="argument cidr_block", value=cidr_block, expected_type=type_hints["cidr_block"])
            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
            check_type(argname="argument assign_ipv6_address_on_creation", value=assign_ipv6_address_on_creation, expected_type=type_hints["assign_ipv6_address_on_creation"])
            check_type(argname="argument ipv6_cidr_block", value=ipv6_cidr_block, expected_type=type_hints["ipv6_cidr_block"])
            check_type(argname="argument map_public_ip_on_launch", value=map_public_ip_on_launch, expected_type=type_hints["map_public_ip_on_launch"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "availability_zone": availability_zone,
            "cidr_block": cidr_block,
            "vpc_id": vpc_id,
        }
        if assign_ipv6_address_on_creation is not None:
            self._values["assign_ipv6_address_on_creation"] = assign_ipv6_address_on_creation
        if ipv6_cidr_block is not None:
            self._values["ipv6_cidr_block"] = ipv6_cidr_block
        if map_public_ip_on_launch is not None:
            self._values["map_public_ip_on_launch"] = map_public_ip_on_launch

    @builtins.property
    def availability_zone(self) -> builtins.str:
        '''The availability zone for the subnet.'''
        result = self._values.get("availability_zone")
        assert result is not None, "Required property 'availability_zone' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def cidr_block(self) -> builtins.str:
        '''The CIDR notation for this subnet.'''
        result = self._values.get("cidr_block")
        assert result is not None, "Required property 'cidr_block' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def vpc_id(self) -> builtins.str:
        '''The VPC which this subnet is part of.'''
        result = self._values.get("vpc_id")
        assert result is not None, "Required property 'vpc_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def assign_ipv6_address_on_creation(self) -> typing.Optional[builtins.bool]:
        '''Indicates whether a network interface created in this subnet receives an IPv6 address.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: false
        '''
        result = self._values.get("assign_ipv6_address_on_creation")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
        '''The IPv6 CIDR block.

        If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.

        :default: - no IPv6 CIDR block.
        '''
        result = self._values.get("ipv6_cidr_block")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def map_public_ip_on_launch(self) -> typing.Optional[builtins.bool]:
        '''Controls if a public IP is associated to an instance at launch.

        :default: true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.
        '''
        result = self._values.get("map_public_ip_on_launch")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "PublicSubnetProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class VpnConnection(
    VpnConnectionBase,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.VpnConnection",
):
    '''Define a VPN Connection.

    :resource: AWS::EC2::VPNConnection
    :exampleMetadata: fixture=with-vpc infused

    Example::

        # Across all tunnels in the account/region
        all_data_out = ec2.VpnConnection.metric_all_tunnel_data_out()
        
        # For a specific vpn connection
        vpn_connection = vpc.add_vpn_connection("Dynamic",
            ip="1.2.3.4"
        )
        state = vpn_connection.metric_tunnel_state()
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        ip: builtins.str,
        asn: typing.Optional[jsii.Number] = None,
        static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
        tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC to connect to.
        :param ip: The ip address of the customer gateway.
        :param asn: The ASN of the customer gateway. Default: 65000
        :param static_routes: The static routes to be routed from the VPN gateway to the customer gateway. Default: Dynamic routing (BGP)
        :param tunnel_options: The tunnel options for the VPN connection. At most two elements (one per tunnel). Duplicates not allowed. Default: Amazon generated tunnel options
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ad1f4749c744eee2a7aea665daf689e9e745492f79e272f28e7a513dce0d4f6)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = VpnConnectionProps(
            vpc=vpc,
            ip=ip,
            asn=asn,
            static_routes=static_routes,
            tunnel_options=tunnel_options,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromVpnConnectionAttributes")
    @builtins.classmethod
    def from_vpn_connection_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        customer_gateway_asn: jsii.Number,
        customer_gateway_id: builtins.str,
        customer_gateway_ip: builtins.str,
        vpn_id: builtins.str,
    ) -> IVpnConnection:
        '''Import a VPN connection by supplying all attributes directly.

        :param scope: -
        :param id: -
        :param customer_gateway_asn: The ASN of the customer gateway.
        :param customer_gateway_id: The id of the customer gateway.
        :param customer_gateway_ip: The ip address of the customer gateway.
        :param vpn_id: The id of the VPN connection.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2195d4dd860bd8c475c90b56ac0c4772abb9198b6dfc1eb0bda033e9bfba395c)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = VpnConnectionAttributes(
            customer_gateway_asn=customer_gateway_asn,
            customer_gateway_id=customer_gateway_id,
            customer_gateway_ip=customer_gateway_ip,
            vpn_id=vpn_id,
        )

        return typing.cast(IVpnConnection, jsii.sinvoke(cls, "fromVpnConnectionAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="metricAll")
    @builtins.classmethod
    def metric_all(
        cls,
        metric_name: builtins.str,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Return the given named metric for all VPN connections in the account/region.

        :param metric_name: -
        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bae7a2df51c395d1a24d11925c809c17449294a288dc41db5331ecdee31f4f84)
            check_type(argname="argument metric_name", value=metric_name, expected_type=type_hints["metric_name"])
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.sinvoke(cls, "metricAll", [metric_name, props]))

    @jsii.member(jsii_name="metricAllTunnelDataIn")
    @builtins.classmethod
    def metric_all_tunnel_data_in(
        cls,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Metric for the tunnel data in of all VPN connections in the account/region.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: sum over 5 minutes
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.sinvoke(cls, "metricAllTunnelDataIn", [props]))

    @jsii.member(jsii_name="metricAllTunnelDataOut")
    @builtins.classmethod
    def metric_all_tunnel_data_out(
        cls,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Metric for the tunnel data out of all VPN connections.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: sum over 5 minutes
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.sinvoke(cls, "metricAllTunnelDataOut", [props]))

    @jsii.member(jsii_name="metricAllTunnelState")
    @builtins.classmethod
    def metric_all_tunnel_state(
        cls,
        *,
        account: typing.Optional[builtins.str] = None,
        color: typing.Optional[builtins.str] = None,
        dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        label: typing.Optional[builtins.str] = None,
        period: typing.Optional[_Duration_4839e8c3] = None,
        region: typing.Optional[builtins.str] = None,
        statistic: typing.Optional[builtins.str] = None,
        unit: typing.Optional[_Unit_61bc6f70] = None,
    ) -> _Metric_e396a4dc:
        '''Metric for the tunnel state of all VPN connections in the account/region.

        :param account: Account which this metric comes from. Default: - Deployment account.
        :param color: The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph. The ``Color`` class has a set of standard colors that can be used here. Default: - Automatic color
        :param dimensions_map: Dimensions of the metric. Default: - No dimensions.
        :param label: Label for this metric when added to a Graph in a Dashboard. You can use `dynamic labels <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html>`_ to show summary information about the entire displayed time series in the legend. For example, if you use:: [max: ${MAX}] MyMetric As the metric label, the maximum value in the visible range will be shown next to the time series name in the graph's legend. Default: - No label
        :param period: The period over which the specified statistic is applied. Default: Duration.minutes(5)
        :param region: Region which this metric comes from. Default: - Deployment region.
        :param statistic: What function to use for aggregating. Use the ``aws_cloudwatch.Stats`` helper class to construct valid input strings. Can be one of the following: - "Minimum" | "min" - "Maximum" | "max" - "Average" | "avg" - "Sum" | "sum" - "SampleCount | "n" - "pNN.NN" - "tmNN.NN" | "tm(NN.NN%:NN.NN%)" - "iqm" - "wmNN.NN" | "wm(NN.NN%:NN.NN%)" - "tcNN.NN" | "tc(NN.NN%:NN.NN%)" - "tsNN.NN" | "ts(NN.NN%:NN.NN%)" Default: Average
        :param unit: Unit used to filter the metric stream. Only refer to datums emitted to the metric stream with the given unit and ignore all others. Only useful when datums are being emitted to the same metric stream under different units. The default is to use all matric datums in the stream, regardless of unit, which is recommended in nearly all cases. CloudWatch does not honor this property for graphs. Default: - All metric datums in the given metric stream

        :default: average over 5 minutes
        '''
        props = _MetricOptions_1788b62f(
            account=account,
            color=color,
            dimensions_map=dimensions_map,
            label=label,
            period=period,
            region=region,
            statistic=statistic,
            unit=unit,
        )

        return typing.cast(_Metric_e396a4dc, jsii.sinvoke(cls, "metricAllTunnelState", [props]))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayAsn")
    def customer_gateway_asn(self) -> jsii.Number:
        '''The ASN of the customer gateway.'''
        return typing.cast(jsii.Number, jsii.get(self, "customerGatewayAsn"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayId")
    def customer_gateway_id(self) -> builtins.str:
        '''The id of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayId"))

    @builtins.property
    @jsii.member(jsii_name="customerGatewayIp")
    def customer_gateway_ip(self) -> builtins.str:
        '''The ip address of the customer gateway.'''
        return typing.cast(builtins.str, jsii.get(self, "customerGatewayIp"))

    @builtins.property
    @jsii.member(jsii_name="vpnId")
    def vpn_id(self) -> builtins.str:
        '''The id of the VPN connection.'''
        return typing.cast(builtins.str, jsii.get(self, "vpnId"))


class WindowsImage(
    GenericSSMParameterImage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.WindowsImage",
):
    '''Select the latest version of the indicated Windows version.

    This Machine Image automatically updates to the latest version on every
    deployment. Be aware this will cause your instances to be replaced when a
    new version of the image becomes available. Do not store stateful information
    on the instance if you are using this image.

    The AMI ID is selected using the values published to the SSM parameter store.

    https://aws.amazon.com/blogs/mt/query-for-the-latest-windows-ami-using-systems-manager-parameter-store/

    :exampleMetadata: lit=aws-autoscaling/test/example.images.lit.ts infused

    Example::

        # Pick a Windows edition to use
        windows = ec2.WindowsImage(ec2.WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE)
        
        # Pick the right Amazon Linux edition. All arguments shown are optional
        # and will default to these values when omitted.
        amzn_linux = ec2.AmazonLinuxImage(
            generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            virtualization=ec2.AmazonLinuxVirt.HVM,
            storage=ec2.AmazonLinuxStorage.GENERAL_PURPOSE
        )
        
        # For other custom (Linux) images, instantiate a `GenericLinuxImage` with
        # a map giving the AMI to in for each region:
        
        linux = ec2.GenericLinuxImage({
            "us-east-1": "ami-97785bed",
            "eu-west-1": "ami-12345678"
        })
    '''

    def __init__(
        self,
        version: WindowsVersion,
        *,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param version: -
        :param user_data: Initial user data. Default: - Empty UserData for Windows machines
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__32495f3fa6cd0ef19c634059a1e1f8e8a04a16f6bcf1501d64054d951d3876e9)
            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
        props = WindowsImageProps(user_data=user_data)

        jsii.create(self.__class__, self, [version, props])


class AmazonLinux2022ImageSsmParameter(
    AmazonLinuxImageSsmParameterBase,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2022ImageSsmParameter",
):
    '''A SSM Parameter that contains the AMI ID for Amazon Linux 2023.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # amazon_linux2022_kernel: ec2.AmazonLinux2022Kernel
        # user_data: ec2.UserData
        
        amazon_linux2022_image_ssm_parameter = ec2.AmazonLinux2022ImageSsmParameter(
            cached_in_context=False,
            cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            kernel=amazon_linux2022_kernel,
            user_data=user_data
        )
    '''

    def __init__(
        self,
        *,
        kernel: typing.Optional[AmazonLinux2022Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2022ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="ssmParameterName")
    @builtins.classmethod
    def ssm_parameter_name(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2022Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> builtins.str:
        '''Generates a SSM Parameter name for a specific amazon linux 2022 AMI.

        Example values::

           "/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-5.15-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-default-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-5.15-arm64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-5.15-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-5.15-arm64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-default-arm64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-minimal-kernel-default-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2022-ami-kernel-default-arm64",

        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2022ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(builtins.str, jsii.sinvoke(cls, "ssmParameterName", [props]))


class AmazonLinux2023ImageSsmParameter(
    AmazonLinuxImageSsmParameterBase,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2023ImageSsmParameter",
):
    '''A SSM Parameter that contains the AMI ID for Amazon Linux 2023.

    :exampleMetadata: infused

    Example::

        # vpc: ec2.Vpc
        
        
        ec2.Instance(self, "LatestAl2023",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
            machine_image=ec2.MachineImage.latest_amazon_linux2023(
                cached_in_context=True
            )
        )
        
        # or
        ec2.Instance(self, "LatestAl2023",
            vpc=vpc,
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
            # context cache is turned on by default
            machine_image=ec2.AmazonLinux2023ImageSsmParameter()
        )
    '''

    def __init__(
        self,
        *,
        kernel: typing.Optional[AmazonLinux2023Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2023ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="ssmParameterName")
    @builtins.classmethod
    def ssm_parameter_name(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2023Kernel] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> builtins.str:
        '''Generates a SSM Parameter name for a specific amazon linux 2023 AMI.

        Example values::

           "/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-arm64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-6.1-arm64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-6.1-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-arm64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64",
           "/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64",

        :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2023ImageSsmParameterProps(
            kernel=kernel,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(builtins.str, jsii.sinvoke(cls, "ssmParameterName", [props]))


class AmazonLinux2ImageSsmParameter(
    AmazonLinuxImageSsmParameterBase,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2ImageSsmParameter",
):
    '''A SSM Parameter that contains the AMI ID for Amazon Linux 2.

    :exampleMetadata: fixture=_generated

    Example::

        # The code below shows an example of how to instantiate this type.
        # The values are placeholders you should change.
        from aws_cdk import aws_ec2 as ec2
        
        # amazon_linux2_kernel: ec2.AmazonLinux2Kernel
        # user_data: ec2.UserData
        
        amazon_linux2_image_ssm_parameter = ec2.AmazonLinux2ImageSsmParameter(
            cached_in_context=False,
            cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
            edition=ec2.AmazonLinuxEdition.STANDARD,
            kernel=amazon_linux2_kernel,
            storage=ec2.AmazonLinuxStorage.EBS,
            user_data=user_data,
            virtualization=ec2.AmazonLinuxVirt.HVM
        )
    '''

    def __init__(
        self,
        *,
        kernel: typing.Optional[AmazonLinux2Kernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> None:
        '''
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param virtualization: Virtualization type. Default: HVM
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2ImageSsmParameterProps(
            kernel=kernel,
            storage=storage,
            virtualization=virtualization,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="ssmParameterName")
    @builtins.classmethod
    def ssm_parameter_name(
        cls,
        *,
        kernel: typing.Optional[AmazonLinux2Kernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        cached_in_context: typing.Optional[builtins.bool] = None,
        user_data: typing.Optional[UserData] = None,
    ) -> builtins.str:
        '''Generates a SSM Parameter name for a specific amazon linux 2 AMI.

        Example values::

           "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-ebs",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-ebs",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-arm64-gp2",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-minimal-hvm-arm64-ebs",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-arm64-gp2",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-kernel-5.10-hvm-x86_64-gp2",
           "/aws/service/ami-amazon-linux-latest/amzn2-ami-minimal-hvm-x86_64-ebs"

        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param virtualization: Virtualization type. Default: HVM
        :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
        :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        '''
        props = AmazonLinux2ImageSsmParameterProps(
            kernel=kernel,
            storage=storage,
            virtualization=virtualization,
            cpu_type=cpu_type,
            edition=edition,
            cached_in_context=cached_in_context,
            user_data=user_data,
        )

        return typing.cast(builtins.str, jsii.sinvoke(cls, "ssmParameterName", [props]))


class AmazonLinuxImage(
    GenericSSMParameterImage,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImage",
):
    '''Selects the latest version of Amazon Linux.

    This Machine Image automatically updates to the latest version on every
    deployment. Be aware this will cause your instances to be replaced when a
    new version of the image becomes available. Do not store stateful information
    on the instance if you are using this image.

    The AMI ID is selected using the values published to the SSM parameter store.

    :exampleMetadata: infused

    Example::

        sg = ec2.SecurityGroup.from_security_group_id(self, "FsxSecurityGroup", "{SECURITY-GROUP-ID}")
        fs = fsx.LustreFileSystem.from_lustre_file_system_attributes(self, "FsxLustreFileSystem",
            dns_name="{FILE-SYSTEM-DNS-NAME}",
            file_system_id="{FILE-SYSTEM-ID}",
            security_group=sg
        )
        
        vpc = ec2.Vpc.from_vpc_attributes(self, "Vpc",
            availability_zones=["us-west-2a", "us-west-2b"],
            public_subnet_ids=["{US-WEST-2A-SUBNET-ID}", "{US-WEST-2B-SUBNET-ID}"],
            vpc_id="{VPC-ID}"
        )
        
        inst = ec2.Instance(self, "inst",
            instance_type=ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.LARGE),
            machine_image=ec2.AmazonLinuxImage(
                generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2
            ),
            vpc=vpc,
            vpc_subnets=ec2.SubnetSelection(
                subnet_type=ec2.SubnetType.PUBLIC
            )
        )
        
        fs.connections.allow_default_port_from(inst)
    '''

    def __init__(
        self,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        generation: typing.Optional[AmazonLinuxGeneration] = None,
        kernel: typing.Optional[AmazonLinuxKernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        user_data: typing.Optional[UserData] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
    ) -> None:
        '''
        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param cpu_type: CPU Type. Default: X86_64
        :param edition: What edition of Amazon Linux to use. Default: Standard
        :param generation: What generation of Amazon Linux to use. Default: AmazonLinux
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param virtualization: Virtualization type. Default: HVM
        '''
        props = AmazonLinuxImageProps(
            cached_in_context=cached_in_context,
            cpu_type=cpu_type,
            edition=edition,
            generation=generation,
            kernel=kernel,
            storage=storage,
            user_data=user_data,
            virtualization=virtualization,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="ssmParameterName")
    @builtins.classmethod
    def ssm_parameter_name(
        cls,
        *,
        cached_in_context: typing.Optional[builtins.bool] = None,
        cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
        edition: typing.Optional[AmazonLinuxEdition] = None,
        generation: typing.Optional[AmazonLinuxGeneration] = None,
        kernel: typing.Optional[AmazonLinuxKernel] = None,
        storage: typing.Optional[AmazonLinuxStorage] = None,
        user_data: typing.Optional[UserData] = None,
        virtualization: typing.Optional[AmazonLinuxVirt] = None,
    ) -> builtins.str:
        '''Return the SSM parameter name that will contain the Amazon Linux image with the given attributes.

        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
        :param cpu_type: CPU Type. Default: X86_64
        :param edition: What edition of Amazon Linux to use. Default: Standard
        :param generation: What generation of Amazon Linux to use. Default: AmazonLinux
        :param kernel: What kernel version of Amazon Linux to use. Default: -
        :param storage: What storage backed image to use. Default: GeneralPurpose
        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
        :param virtualization: Virtualization type. Default: HVM
        '''
        props = AmazonLinuxImageProps(
            cached_in_context=cached_in_context,
            cpu_type=cpu_type,
            edition=edition,
            generation=generation,
            kernel=kernel,
            storage=storage,
            user_data=user_data,
            virtualization=virtualization,
        )

        return typing.cast(builtins.str, jsii.sinvoke(cls, "ssmParameterName", [props]))

    @jsii.member(jsii_name="getImage")
    def get_image(self, scope: _constructs_77d1e7e8.Construct) -> MachineImageConfig:
        '''Return the image to use in the given context.

        :param scope: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d36c8ea8f8238c750dcfc9d1f369becc11ed2416802179e3a5e681794171bcf3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast(MachineImageConfig, jsii.invoke(self, "getImage", [scope]))


@jsii.implements(IClientVpnEndpoint)
class ClientVpnEndpoint(
    _Resource_45bc6135,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.ClientVpnEndpoint",
):
    '''A client VPN connnection.

    :exampleMetadata: fixture=client-vpn infused

    Example::

        endpoint = vpc.add_client_vpn_endpoint("Endpoint",
            cidr="10.100.0.0/16",
            server_certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/server-certificate-id",
            user_based_authentication=ec2.ClientVpnUserBasedAuthentication.federated(saml_provider),
            authorize_all_users_to_vpc_cidr=False
        )
        
        endpoint.add_authorization_rule("Rule",
            cidr="10.0.10.0/32",
            group_id="group-id"
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        cidr: builtins.str,
        server_certificate_arn: builtins.str,
        authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
        client_certificate_arn: typing.Optional[builtins.str] = None,
        client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
        client_login_banner: typing.Optional[builtins.str] = None,
        description: typing.Optional[builtins.str] = None,
        dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
        logging: typing.Optional[builtins.bool] = None,
        log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
        log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
        port: typing.Optional[VpnPort] = None,
        security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
        self_service_portal: typing.Optional[builtins.bool] = None,
        session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
        split_tunnel: typing.Optional[builtins.bool] = None,
        transport_protocol: typing.Optional[TransportProtocol] = None,
        user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
        vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC to connect to.
        :param cidr: The IPv4 address range, in CIDR notation, from which to assign client IP addresses. The address range cannot overlap with the local CIDR of the VPC in which the associated subnet is located, or the routes that you add manually. Changing the address range will replace the Client VPN endpoint. The CIDR block should be /22 or greater.
        :param server_certificate_arn: The ARN of the server certificate.
        :param authorize_all_users_to_vpc_cidr: Whether to authorize all users to the VPC CIDR. This automatically creates an authorization rule. Set this to ``false`` and use ``addAuthorizationRule()`` to create your own rules instead. Default: true
        :param client_certificate_arn: The ARN of the client certificate for mutual authentication. The certificate must be signed by a certificate authority (CA) and it must be provisioned in AWS Certificate Manager (ACM). Default: - use user-based authentication
        :param client_connection_handler: The AWS Lambda function used for connection authorization. The name of the Lambda function must begin with the ``AWSClientVPN-`` prefix Default: - no connection handler
        :param client_login_banner: Customizable text that will be displayed in a banner on AWS provided clients when a VPN session is established. UTF-8 encoded characters only. Maximum of 1400 characters. Default: - no banner is presented to the client
        :param description: A brief description of the Client VPN endpoint. Default: - no description
        :param dns_servers: Information about the DNS servers to be used for DNS resolution. A Client VPN endpoint can have up to two DNS servers. Default: - use the DNS address configured on the device
        :param logging: Whether to enable connections logging. Default: true
        :param log_group: A CloudWatch Logs log group for connection logging. Default: - a new group is created
        :param log_stream: A CloudWatch Logs log stream for connection logging. Default: - a new stream is created
        :param port: The port number to assign to the Client VPN endpoint for TCP and UDP traffic. Default: VpnPort.HTTPS
        :param security_groups: The security groups to apply to the target network. Default: - a new security group is created
        :param self_service_portal: Specify whether to enable the self-service portal for the Client VPN endpoint. Default: true
        :param session_timeout: The maximum VPN session duration time. Default: ClientVpnSessionTimeout.TWENTY_FOUR_HOURS
        :param split_tunnel: Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint. Default: false
        :param transport_protocol: The transport protocol to be used by the VPN session. Default: TransportProtocol.UDP
        :param user_based_authentication: The type of user-based authentication to use. Default: - use mutual authentication
        :param vpc_subnets: Subnets to associate to the client VPN endpoint. Default: - the VPC default strategy
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9a2422e1dfabadbd7f572317ed37670a87714b6f36fe9da2a01f1e26e1c69e29)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ClientVpnEndpointProps(
            vpc=vpc,
            cidr=cidr,
            server_certificate_arn=server_certificate_arn,
            authorize_all_users_to_vpc_cidr=authorize_all_users_to_vpc_cidr,
            client_certificate_arn=client_certificate_arn,
            client_connection_handler=client_connection_handler,
            client_login_banner=client_login_banner,
            description=description,
            dns_servers=dns_servers,
            logging=logging,
            log_group=log_group,
            log_stream=log_stream,
            port=port,
            security_groups=security_groups,
            self_service_portal=self_service_portal,
            session_timeout=session_timeout,
            split_tunnel=split_tunnel,
            transport_protocol=transport_protocol,
            user_based_authentication=user_based_authentication,
            vpc_subnets=vpc_subnets,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromEndpointAttributes")
    @builtins.classmethod
    def from_endpoint_attributes(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        endpoint_id: builtins.str,
        security_groups: typing.Sequence[ISecurityGroup],
    ) -> IClientVpnEndpoint:
        '''Import an existing client VPN endpoint.

        :param scope: -
        :param id: -
        :param endpoint_id: The endpoint ID.
        :param security_groups: The security groups associated with the endpoint.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6c8aae9e1203b18f83d41ca4fddea01d559c58720761ab0edaadc55bd45ea263)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        attrs = ClientVpnEndpointAttributes(
            endpoint_id=endpoint_id, security_groups=security_groups
        )

        return typing.cast(IClientVpnEndpoint, jsii.sinvoke(cls, "fromEndpointAttributes", [scope, id, attrs]))

    @jsii.member(jsii_name="addAuthorizationRule")
    def add_authorization_rule(
        self,
        id: builtins.str,
        *,
        cidr: builtins.str,
        description: typing.Optional[builtins.str] = None,
        group_id: typing.Optional[builtins.str] = None,
    ) -> ClientVpnAuthorizationRule:
        '''Adds an authorization rule to this endpoint.

        :param id: -
        :param cidr: The IPv4 address range, in CIDR notation, of the network for which access is being authorized.
        :param description: A brief description of the authorization rule. Default: - no description
        :param group_id: The ID of the group to grant access to, for example, the Active Directory group or identity provider (IdP) group. Default: - authorize all groups
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3855a1aa89a893cd0b343fcfc8057121ad85f505d9d981df23ee816d1e3b4178)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ClientVpnAuthorizationRuleOptions(
            cidr=cidr, description=description, group_id=group_id
        )

        return typing.cast(ClientVpnAuthorizationRule, jsii.invoke(self, "addAuthorizationRule", [id, props]))

    @jsii.member(jsii_name="addRoute")
    def add_route(
        self,
        id: builtins.str,
        *,
        cidr: builtins.str,
        target: ClientVpnRouteTarget,
        description: typing.Optional[builtins.str] = None,
    ) -> ClientVpnRoute:
        '''Adds a route to this endpoint.

        :param id: -
        :param cidr: The IPv4 address range, in CIDR notation, of the route destination. For example: - To add a route for Internet access, enter 0.0.0.0/0 - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range - To add a route for an on-premises network, enter the AWS Site-to-Site VPN connection's IPv4 CIDR range - To add a route for the local network, enter the client CIDR range
        :param target: The target for the route.
        :param description: A brief description of the authorization rule. Default: - no description
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53fff4bf7ec1dc9a6f6333e9799446eb686a1cd207e61c471f22cfedf94e895d)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = ClientVpnRouteOptions(
            cidr=cidr, target=target, description=description
        )

        return typing.cast(ClientVpnRoute, jsii.invoke(self, "addRoute", [id, props]))

    @builtins.property
    @jsii.member(jsii_name="connections")
    def connections(self) -> Connections:
        '''Allows specify security group connections for the endpoint.'''
        return typing.cast(Connections, jsii.get(self, "connections"))

    @builtins.property
    @jsii.member(jsii_name="endpointId")
    def endpoint_id(self) -> builtins.str:
        '''The endpoint ID.'''
        return typing.cast(builtins.str, jsii.get(self, "endpointId"))

    @builtins.property
    @jsii.member(jsii_name="targetNetworksAssociated")
    def target_networks_associated(self) -> _constructs_77d1e7e8.IDependable:
        '''Dependable that can be depended upon to force target networks associations.'''
        return typing.cast(_constructs_77d1e7e8.IDependable, jsii.get(self, "targetNetworksAssociated"))


@jsii.implements(IGatewayVpcEndpoint)
class GatewayVpcEndpoint(
    VpcEndpoint,
    metaclass=jsii.JSIIMeta,
    jsii_type="aws-cdk-lib.aws_ec2.GatewayVpcEndpoint",
):
    '''A gateway VPC endpoint.

    :resource: AWS::EC2::VPCEndpoint
    :exampleMetadata: lit=aws-ec2/test/integ.vpc-endpoint.lit.ts infused

    Example::

        # Add gateway endpoints when creating the VPC
        vpc = ec2.Vpc(self, "MyVpc",
            gateway_endpoints={
                "S3": cdk.aws_ec2.GatewayVpcEndpointOptions(
                    service=ec2.GatewayVpcEndpointAwsService.S3
                )
            }
        )
        
        # Alternatively gateway endpoints can be added on the VPC
        dynamo_db_endpoint = vpc.add_gateway_endpoint("DynamoDbEndpoint",
            service=ec2.GatewayVpcEndpointAwsService.DYNAMODB
        )
        
        # This allows to customize the endpoint policy
        dynamo_db_endpoint.add_to_policy(
            iam.PolicyStatement( # Restrict to listing and describing tables
                principals=[iam.AnyPrincipal()],
                actions=["dynamodb:DescribeTable", "dynamodb:ListTables"],
                resources=["*"]))
        
        # Add an interface endpoint
        vpc.add_interface_endpoint("EcrDockerEndpoint",
            service=ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER
        )
    '''

    def __init__(
        self,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        *,
        vpc: IVpc,
        service: IGatewayVpcEndpointService,
        subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param vpc: The VPC network in which the gateway endpoint will be used.
        :param service: The service to use for this gateway VPC endpoint.
        :param subnets: Where to add endpoint routing. By default, this endpoint will be routable from all subnets in the VPC. Specify a list of subnet selection objects here to be more specific. Default: - All subnets in the VPC
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e6b639e9e272c3dda7a0da668a80b8667ec45c4335a7254fad62ea4903fbf925)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = GatewayVpcEndpointProps(vpc=vpc, service=service, subnets=subnets)

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="fromGatewayVpcEndpointId")
    @builtins.classmethod
    def from_gateway_vpc_endpoint_id(
        cls,
        scope: _constructs_77d1e7e8.Construct,
        id: builtins.str,
        gateway_vpc_endpoint_id: builtins.str,
    ) -> IGatewayVpcEndpoint:
        '''
        :param scope: -
        :param id: -
        :param gateway_vpc_endpoint_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e30701d75e15889685bae2b128365e2a821d36118234985bd896751e5501712)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument gateway_vpc_endpoint_id", value=gateway_vpc_endpoint_id, expected_type=type_hints["gateway_vpc_endpoint_id"])
        return typing.cast(IGatewayVpcEndpoint, jsii.sinvoke(cls, "fromGatewayVpcEndpointId", [scope, id, gateway_vpc_endpoint_id]))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointCreationTimestamp")
    def vpc_endpoint_creation_timestamp(self) -> builtins.str:
        '''The date and time the gateway VPC endpoint was created.

        :attribute: true
        '''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointCreationTimestamp"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointDnsEntries")
    def vpc_endpoint_dns_entries(self) -> typing.List[builtins.str]:
        '''
        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcEndpointDnsEntries"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointId")
    def vpc_endpoint_id(self) -> builtins.str:
        '''The gateway VPC endpoint identifier.'''
        return typing.cast(builtins.str, jsii.get(self, "vpcEndpointId"))

    @builtins.property
    @jsii.member(jsii_name="vpcEndpointNetworkInterfaceIds")
    def vpc_endpoint_network_interface_ids(self) -> typing.List[builtins.str]:
        '''
        :attribute: true
        '''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "vpcEndpointNetworkInterfaceIds"))


__all__ = [
    "AclCidr",
    "AclCidrConfig",
    "AclIcmp",
    "AclPortRange",
    "AclTraffic",
    "AclTrafficConfig",
    "Action",
    "AddRouteOptions",
    "AddressFamily",
    "AllocateCidrRequest",
    "AllocateIpv6CidrRequest",
    "AllocateVpcIpv6CidrRequest",
    "AllocatedSubnet",
    "AmazonLinux2022ImageSsmParameter",
    "AmazonLinux2022ImageSsmParameterProps",
    "AmazonLinux2022Kernel",
    "AmazonLinux2023ImageSsmParameter",
    "AmazonLinux2023ImageSsmParameterProps",
    "AmazonLinux2023Kernel",
    "AmazonLinux2ImageSsmParameter",
    "AmazonLinux2ImageSsmParameterProps",
    "AmazonLinux2Kernel",
    "AmazonLinuxCpuType",
    "AmazonLinuxEdition",
    "AmazonLinuxGeneration",
    "AmazonLinuxImage",
    "AmazonLinuxImageProps",
    "AmazonLinuxImageSsmParameterBase",
    "AmazonLinuxImageSsmParameterBaseOptions",
    "AmazonLinuxImageSsmParameterBaseProps",
    "AmazonLinuxImageSsmParameterCommonOptions",
    "AmazonLinuxKernel",
    "AmazonLinuxStorage",
    "AmazonLinuxVirt",
    "ApplyCloudFormationInitOptions",
    "AttachInitOptions",
    "AwsIpamProps",
    "BastionHostLinux",
    "BastionHostLinuxProps",
    "BlockDevice",
    "BlockDeviceVolume",
    "CfnCapacityReservation",
    "CfnCapacityReservationFleet",
    "CfnCapacityReservationFleetProps",
    "CfnCapacityReservationProps",
    "CfnCarrierGateway",
    "CfnCarrierGatewayProps",
    "CfnClientVpnAuthorizationRule",
    "CfnClientVpnAuthorizationRuleProps",
    "CfnClientVpnEndpoint",
    "CfnClientVpnEndpointProps",
    "CfnClientVpnRoute",
    "CfnClientVpnRouteProps",
    "CfnClientVpnTargetNetworkAssociation",
    "CfnClientVpnTargetNetworkAssociationProps",
    "CfnCustomerGateway",
    "CfnCustomerGatewayProps",
    "CfnDHCPOptions",
    "CfnDHCPOptionsProps",
    "CfnEC2Fleet",
    "CfnEC2FleetProps",
    "CfnEIP",
    "CfnEIPAssociation",
    "CfnEIPAssociationProps",
    "CfnEIPProps",
    "CfnEgressOnlyInternetGateway",
    "CfnEgressOnlyInternetGatewayProps",
    "CfnEnclaveCertificateIamRoleAssociation",
    "CfnEnclaveCertificateIamRoleAssociationProps",
    "CfnFlowLog",
    "CfnFlowLogProps",
    "CfnGatewayRouteTableAssociation",
    "CfnGatewayRouteTableAssociationProps",
    "CfnHost",
    "CfnHostProps",
    "CfnIPAM",
    "CfnIPAMAllocation",
    "CfnIPAMAllocationProps",
    "CfnIPAMPool",
    "CfnIPAMPoolCidr",
    "CfnIPAMPoolCidrProps",
    "CfnIPAMPoolProps",
    "CfnIPAMProps",
    "CfnIPAMResourceDiscovery",
    "CfnIPAMResourceDiscoveryAssociation",
    "CfnIPAMResourceDiscoveryAssociationProps",
    "CfnIPAMResourceDiscoveryProps",
    "CfnIPAMScope",
    "CfnIPAMScopeProps",
    "CfnInstance",
    "CfnInstanceConnectEndpoint",
    "CfnInstanceConnectEndpointProps",
    "CfnInstanceProps",
    "CfnInternetGateway",
    "CfnInternetGatewayProps",
    "CfnKeyPair",
    "CfnKeyPairProps",
    "CfnLaunchTemplate",
    "CfnLaunchTemplateProps",
    "CfnLocalGatewayRoute",
    "CfnLocalGatewayRouteProps",
    "CfnLocalGatewayRouteTable",
    "CfnLocalGatewayRouteTableProps",
    "CfnLocalGatewayRouteTableVPCAssociation",
    "CfnLocalGatewayRouteTableVPCAssociationProps",
    "CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociation",
    "CfnLocalGatewayRouteTableVirtualInterfaceGroupAssociationProps",
    "CfnNatGateway",
    "CfnNatGatewayProps",
    "CfnNetworkAcl",
    "CfnNetworkAclEntry",
    "CfnNetworkAclEntryProps",
    "CfnNetworkAclProps",
    "CfnNetworkInsightsAccessScope",
    "CfnNetworkInsightsAccessScopeAnalysis",
    "CfnNetworkInsightsAccessScopeAnalysisProps",
    "CfnNetworkInsightsAccessScopeProps",
    "CfnNetworkInsightsAnalysis",
    "CfnNetworkInsightsAnalysisProps",
    "CfnNetworkInsightsPath",
    "CfnNetworkInsightsPathProps",
    "CfnNetworkInterface",
    "CfnNetworkInterfaceAttachment",
    "CfnNetworkInterfaceAttachmentProps",
    "CfnNetworkInterfacePermission",
    "CfnNetworkInterfacePermissionProps",
    "CfnNetworkInterfaceProps",
    "CfnNetworkPerformanceMetricSubscription",
    "CfnNetworkPerformanceMetricSubscriptionProps",
    "CfnPlacementGroup",
    "CfnPlacementGroupProps",
    "CfnPrefixList",
    "CfnPrefixListProps",
    "CfnRoute",
    "CfnRouteProps",
    "CfnRouteTable",
    "CfnRouteTableProps",
    "CfnSecurityGroup",
    "CfnSecurityGroupEgress",
    "CfnSecurityGroupEgressProps",
    "CfnSecurityGroupIngress",
    "CfnSecurityGroupIngressProps",
    "CfnSecurityGroupProps",
    "CfnSnapshotBlockPublicAccess",
    "CfnSnapshotBlockPublicAccessProps",
    "CfnSpotFleet",
    "CfnSpotFleetProps",
    "CfnSubnet",
    "CfnSubnetCidrBlock",
    "CfnSubnetCidrBlockProps",
    "CfnSubnetNetworkAclAssociation",
    "CfnSubnetNetworkAclAssociationProps",
    "CfnSubnetProps",
    "CfnSubnetRouteTableAssociation",
    "CfnSubnetRouteTableAssociationProps",
    "CfnTrafficMirrorFilter",
    "CfnTrafficMirrorFilterProps",
    "CfnTrafficMirrorFilterRule",
    "CfnTrafficMirrorFilterRuleProps",
    "CfnTrafficMirrorSession",
    "CfnTrafficMirrorSessionProps",
    "CfnTrafficMirrorTarget",
    "CfnTrafficMirrorTargetProps",
    "CfnTransitGateway",
    "CfnTransitGatewayAttachment",
    "CfnTransitGatewayAttachmentProps",
    "CfnTransitGatewayConnect",
    "CfnTransitGatewayConnectProps",
    "CfnTransitGatewayMulticastDomain",
    "CfnTransitGatewayMulticastDomainAssociation",
    "CfnTransitGatewayMulticastDomainAssociationProps",
    "CfnTransitGatewayMulticastDomainProps",
    "CfnTransitGatewayMulticastGroupMember",
    "CfnTransitGatewayMulticastGroupMemberProps",
    "CfnTransitGatewayMulticastGroupSource",
    "CfnTransitGatewayMulticastGroupSourceProps",
    "CfnTransitGatewayPeeringAttachment",
    "CfnTransitGatewayPeeringAttachmentProps",
    "CfnTransitGatewayProps",
    "CfnTransitGatewayRoute",
    "CfnTransitGatewayRouteProps",
    "CfnTransitGatewayRouteTable",
    "CfnTransitGatewayRouteTableAssociation",
    "CfnTransitGatewayRouteTableAssociationProps",
    "CfnTransitGatewayRouteTablePropagation",
    "CfnTransitGatewayRouteTablePropagationProps",
    "CfnTransitGatewayRouteTableProps",
    "CfnTransitGatewayVpcAttachment",
    "CfnTransitGatewayVpcAttachmentProps",
    "CfnVPC",
    "CfnVPCCidrBlock",
    "CfnVPCCidrBlockProps",
    "CfnVPCDHCPOptionsAssociation",
    "CfnVPCDHCPOptionsAssociationProps",
    "CfnVPCEndpoint",
    "CfnVPCEndpointConnectionNotification",
    "CfnVPCEndpointConnectionNotificationProps",
    "CfnVPCEndpointProps",
    "CfnVPCEndpointService",
    "CfnVPCEndpointServicePermissions",
    "CfnVPCEndpointServicePermissionsProps",
    "CfnVPCEndpointServiceProps",
    "CfnVPCGatewayAttachment",
    "CfnVPCGatewayAttachmentProps",
    "CfnVPCPeeringConnection",
    "CfnVPCPeeringConnectionProps",
    "CfnVPCProps",
    "CfnVPNConnection",
    "CfnVPNConnectionProps",
    "CfnVPNConnectionRoute",
    "CfnVPNConnectionRouteProps",
    "CfnVPNGateway",
    "CfnVPNGatewayProps",
    "CfnVPNGatewayRoutePropagation",
    "CfnVPNGatewayRoutePropagationProps",
    "CfnVerifiedAccessEndpoint",
    "CfnVerifiedAccessEndpointProps",
    "CfnVerifiedAccessGroup",
    "CfnVerifiedAccessGroupProps",
    "CfnVerifiedAccessInstance",
    "CfnVerifiedAccessInstanceProps",
    "CfnVerifiedAccessTrustProvider",
    "CfnVerifiedAccessTrustProviderProps",
    "CfnVolume",
    "CfnVolumeAttachment",
    "CfnVolumeAttachmentProps",
    "CfnVolumeProps",
    "ClientVpnAuthorizationRule",
    "ClientVpnAuthorizationRuleOptions",
    "ClientVpnAuthorizationRuleProps",
    "ClientVpnEndpoint",
    "ClientVpnEndpointAttributes",
    "ClientVpnEndpointOptions",
    "ClientVpnEndpointProps",
    "ClientVpnRoute",
    "ClientVpnRouteOptions",
    "ClientVpnRouteProps",
    "ClientVpnRouteTarget",
    "ClientVpnSessionTimeout",
    "ClientVpnUserBasedAuthentication",
    "CloudFormationInit",
    "CommonNetworkAclEntryOptions",
    "ConfigSetProps",
    "ConfigureNatOptions",
    "ConnectionRule",
    "Connections",
    "ConnectionsProps",
    "CpuCredits",
    "CreateIpv6CidrBlocksRequest",
    "DefaultInstanceTenancy",
    "DestinationOptions",
    "EbsDeviceOptions",
    "EbsDeviceOptionsBase",
    "EbsDeviceProps",
    "EbsDeviceSnapshotOptions",
    "EbsDeviceVolumeType",
    "EnableVpnGatewayOptions",
    "ExecuteFileOptions",
    "FlowLog",
    "FlowLogDestination",
    "FlowLogDestinationConfig",
    "FlowLogDestinationType",
    "FlowLogFileFormat",
    "FlowLogMaxAggregationInterval",
    "FlowLogOptions",
    "FlowLogProps",
    "FlowLogResourceType",
    "FlowLogTrafficType",
    "GatewayConfig",
    "GatewayVpcEndpoint",
    "GatewayVpcEndpointAwsService",
    "GatewayVpcEndpointOptions",
    "GatewayVpcEndpointProps",
    "GenericLinuxImage",
    "GenericLinuxImageProps",
    "GenericSSMParameterImage",
    "GenericWindowsImage",
    "GenericWindowsImageProps",
    "IClientVpnConnectionHandler",
    "IClientVpnEndpoint",
    "IConnectable",
    "IFlowLog",
    "IGatewayVpcEndpoint",
    "IGatewayVpcEndpointService",
    "IInstance",
    "IInterfaceVpcEndpoint",
    "IInterfaceVpcEndpointService",
    "IIpAddresses",
    "IIpv6Addresses",
    "IKeyPair",
    "ILaunchTemplate",
    "IMachineImage",
    "INetworkAcl",
    "INetworkAclEntry",
    "IPeer",
    "IPlacementGroup",
    "IPrefixList",
    "IPrivateSubnet",
    "IPublicSubnet",
    "IRouteTable",
    "ISecurityGroup",
    "ISubnet",
    "ISubnetNetworkAclAssociation",
    "IVolume",
    "IVpc",
    "IVpcEndpoint",
    "IVpcEndpointService",
    "IVpcEndpointServiceLoadBalancer",
    "IVpnConnection",
    "IVpnGateway",
    "InitCommand",
    "InitCommandOptions",
    "InitCommandWaitDuration",
    "InitConfig",
    "InitElement",
    "InitFile",
    "InitFileAssetOptions",
    "InitFileOptions",
    "InitGroup",
    "InitPackage",
    "InitService",
    "InitServiceOptions",
    "InitServiceRestartHandle",
    "InitSource",
    "InitSourceAssetOptions",
    "InitSourceOptions",
    "InitUser",
    "InitUserOptions",
    "Instance",
    "InstanceArchitecture",
    "InstanceClass",
    "InstanceInitiatedShutdownBehavior",
    "InstanceProps",
    "InstanceRequireImdsv2Aspect",
    "InstanceRequireImdsv2AspectProps",
    "InstanceSize",
    "InstanceType",
    "InterfaceVpcEndpoint",
    "InterfaceVpcEndpointAttributes",
    "InterfaceVpcEndpointAwsService",
    "InterfaceVpcEndpointOptions",
    "InterfaceVpcEndpointProps",
    "InterfaceVpcEndpointService",
    "IpAddresses",
    "IpProtocol",
    "Ipv6Addresses",
    "KeyPair",
    "KeyPairAttributes",
    "KeyPairFormat",
    "KeyPairProps",
    "KeyPairType",
    "LaunchTemplate",
    "LaunchTemplateAttributes",
    "LaunchTemplateHttpTokens",
    "LaunchTemplateProps",
    "LaunchTemplateRequireImdsv2Aspect",
    "LaunchTemplateRequireImdsv2AspectProps",
    "LaunchTemplateSpecialVersions",
    "LaunchTemplateSpotOptions",
    "LinuxUserDataOptions",
    "LocationPackageOptions",
    "LogFormat",
    "LookupMachineImage",
    "LookupMachineImageProps",
    "MachineImage",
    "MachineImageConfig",
    "MultipartBody",
    "MultipartBodyOptions",
    "MultipartUserData",
    "MultipartUserDataOptions",
    "NamedPackageOptions",
    "NatGatewayProps",
    "NatInstanceImage",
    "NatInstanceProps",
    "NatInstanceProvider",
    "NatProvider",
    "NatTrafficDirection",
    "NetworkAcl",
    "NetworkAclEntry",
    "NetworkAclEntryProps",
    "NetworkAclProps",
    "OperatingSystemType",
    "Peer",
    "PlacementGroup",
    "PlacementGroupProps",
    "PlacementGroupSpreadLevel",
    "PlacementGroupStrategy",
    "Port",
    "PortProps",
    "PrefixList",
    "PrefixListOptions",
    "PrefixListProps",
    "PrivateSubnet",
    "PrivateSubnetAttributes",
    "PrivateSubnetProps",
    "Protocol",
    "PublicSubnet",
    "PublicSubnetAttributes",
    "PublicSubnetProps",
    "RequestedSubnet",
    "ResolveSsmParameterAtLaunchImage",
    "RouterType",
    "RuleScope",
    "S3DestinationOptions",
    "S3DownloadOptions",
    "SecurityGroup",
    "SecurityGroupImportOptions",
    "SecurityGroupProps",
    "SelectedSubnets",
    "ServiceManager",
    "SpotInstanceInterruption",
    "SpotRequestType",
    "SsmParameterImageOptions",
    "Subnet",
    "SubnetAttributes",
    "SubnetConfiguration",
    "SubnetFilter",
    "SubnetIpamOptions",
    "SubnetNetworkAclAssociation",
    "SubnetNetworkAclAssociationProps",
    "SubnetProps",
    "SubnetSelection",
    "SubnetType",
    "SystemdConfigFileOptions",
    "TrafficDirection",
    "TransportProtocol",
    "UserData",
    "Volume",
    "VolumeAttributes",
    "VolumeProps",
    "Vpc",
    "VpcAttributes",
    "VpcEndpoint",
    "VpcEndpointService",
    "VpcEndpointServiceProps",
    "VpcEndpointType",
    "VpcIpamOptions",
    "VpcLookupOptions",
    "VpcProps",
    "VpnConnection",
    "VpnConnectionAttributes",
    "VpnConnectionBase",
    "VpnConnectionOptions",
    "VpnConnectionProps",
    "VpnConnectionType",
    "VpnGateway",
    "VpnGatewayProps",
    "VpnPort",
    "VpnTunnelOption",
    "WindowsImage",
    "WindowsImageProps",
    "WindowsUserDataOptions",
    "WindowsVersion",
]

publication.publish()

def _typecheckingstub__f3ad2a5e4919c72fd0ec671df247f101b5b82e588009ce91566c9f396c19964d(
    ipv4_cidr: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab6b9e0c88e64ab22e19f5a242a9ffd751298689bdc4a3606320998b2b7e339d(
    ipv6_cidr: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a528042c63b989d3b0c11f7e3e2d7d5c63ef7f27ec1567d962210008609ac034(
    *,
    cidr_block: typing.Optional[builtins.str] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb17a149fd86e4bb35aa154a67bb9dd9d7ab9c56f326c8456deb5341e61d7f00(
    *,
    code: typing.Optional[jsii.Number] = None,
    type: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c33fb537fef4ba8402530ec5630aee8c8410497a0863ede5f99ca517f82f449(
    *,
    from_: typing.Optional[jsii.Number] = None,
    to: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e173d91f1c1835ccfdf6134dedc027e620c0f44039934fb8a281ef312e37d65(
    port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e335ec8df7c430d1e714bfe44c78e0cbeee9db3e25113497f4dd34eaf73bbf2(
    start_port: jsii.Number,
    end_port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdfed3d1e83596c6d4a6c551d18618296a9bc3f9cb56f39949877474341e83d3(
    port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c14e6bbd7559b33e3aa0635a4f52616c7f7431ee9711dcae11b1b5b3960e432d(
    start_port: jsii.Number,
    end_port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d163c256d269f1d2f5078983924b9ad072aef3816da73da84929680d06b8d0bb(
    *,
    protocol: jsii.Number,
    icmp: typing.Optional[typing.Union[AclIcmp, typing.Dict[builtins.str, typing.Any]]] = None,
    port_range: typing.Optional[typing.Union[AclPortRange, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f59a164a1424d8008d54093d179bfdbc68c5da0cf45fe708c6f2aa4ec7240d43(
    *,
    router_id: builtins.str,
    router_type: RouterType,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
    enables_internet_connectivity: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1df4b2c29495f98d544593b7df7715ec829f51c17796f9e361e366395a4a9b0a(
    *,
    requested_subnets: typing.Sequence[typing.Union[RequestedSubnet, typing.Dict[builtins.str, typing.Any]]],
    vpc_cidr: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d2d15673b9e53df657dc88df46f1098eea51256e5f4addb1db32dc0e2690f00(
    *,
    allocated_subnets: typing.Sequence[typing.Union[AllocatedSubnet, typing.Dict[builtins.str, typing.Any]]],
    ipv6_cidrs: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__201ab4d786fad817892547309e43b9b3ecac389ee3325f1ab6705b11dbd09c0c(
    *,
    scope: _constructs_77d1e7e8.Construct,
    vpc_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cca8efe6fa73141fbec2a2cf91f8f6bf2e0f69d49252bd2d45b21fcb2dce3566(
    *,
    cidr: builtins.str,
    ipv6_cidr: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67731f51c6dad8d404e1a6ed177e5a2605da4ce360058d786cf253f72d1aee3d(
    version: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ab727190b8ad0e28c2d1ddc702af61630c845ff5aedd9578b75429a06aba8f5(
    version: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d9d80aebc17990a8f3419f9444ec1fdd3e5bc1c150c3db0d42eda409806c7a8(
    version: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd95a518c06563a07debc9bf1ca51713b747cf64bded6f7cc81a28680d7ea9fc(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
    edition: typing.Optional[AmazonLinuxEdition] = None,
    generation: typing.Optional[AmazonLinuxGeneration] = None,
    kernel: typing.Optional[AmazonLinuxKernel] = None,
    storage: typing.Optional[AmazonLinuxStorage] = None,
    user_data: typing.Optional[UserData] = None,
    virtualization: typing.Optional[AmazonLinuxVirt] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963ee6333f(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0c7383f1(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    parameter_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8fcdd01a6ab45c77447fba339b5a9358c3ab40c4833c1f86c68009a6a3bb1422(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
    edition: typing.Optional[AmazonLinuxEdition] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7f632381407c0e83d84ca5b16928a38d4d8f6de29513094b92a876e870ddb63(
    *,
    config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
    embed_fingerprint: typing.Optional[builtins.bool] = None,
    ignore_failures: typing.Optional[builtins.bool] = None,
    include_role: typing.Optional[builtins.bool] = None,
    include_url: typing.Optional[builtins.bool] = None,
    print_log: typing.Optional[builtins.bool] = None,
    timeout: typing.Optional[_Duration_4839e8c3] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d40dbbec96cabb7e34633204b5a62ce85e126032034ff03db0d8c739abfb5a2d(
    *,
    instance_role: _IRole_235f5d8e,
    platform: OperatingSystemType,
    user_data: UserData,
    config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
    embed_fingerprint: typing.Optional[builtins.bool] = None,
    ignore_failures: typing.Optional[builtins.bool] = None,
    include_role: typing.Optional[builtins.bool] = None,
    include_url: typing.Optional[builtins.bool] = None,
    print_log: typing.Optional[builtins.bool] = None,
    signal_resource: typing.Optional[_CfnResource_9df397a6] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f03eeb114f6c99cb527203711f14fcc87021cebcc68936ea2dc38a933caa1694(
    *,
    ipv4_ipam_pool_id: builtins.str,
    ipv4_netmask_length: jsii.Number,
    default_subnet_ipv4_netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2647a77163fdd79c5b81f9523b8e35e195386f549d272d3474261e5251a24e52(
    *,
    vpc: IVpc,
    availability_zone: typing.Optional[builtins.str] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    init: typing.Optional[CloudFormationInit] = None,
    init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    instance_name: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[InstanceType] = None,
    machine_image: typing.Optional[IMachineImage] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    subnet_selection: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d6658aae654252e134d66f13fd022e06de0b6f39cf994c929751371e10c0774d(
    *,
    device_name: builtins.str,
    volume: BlockDeviceVolume,
    mapping_enabled: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8805c499a7a0c5dd9580d5a1c8b85b4f543fea2c6e746e9d2815091e05d36c52(
    ebs_device: typing.Optional[typing.Union[EbsDeviceProps, typing.Dict[builtins.str, typing.Any]]] = None,
    virtual_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e34634be08d573bd7d4eca032a2a66e619c889f2b51e62608777ae0db2639e6a(
    volume_size: jsii.Number,
    *,
    encrypted: typing.Optional[builtins.bool] = None,
    kms_key: typing.Optional[_IKey_5f11635f] = None,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce9e60bc1da1c6f1d133c0cfaad0c5984d2f7a428c12f02640d8f31c6eab041e(
    snapshot_id: builtins.str,
    *,
    volume_size: typing.Optional[jsii.Number] = None,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3bf1e1313f470f70824bf7224f1fd91d59ad3cef90451484660764b691d8481(
    volume_index: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96fb3bc559aaa9df971e86ea7cdd3cdc3de550019a2d3bf247d3fb169b5e9f7e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    instance_count: jsii.Number,
    instance_platform: builtins.str,
    instance_type: builtins.str,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    end_date: typing.Optional[builtins.str] = None,
    end_date_type: typing.Optional[builtins.str] = None,
    ephemeral_storage: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    instance_match_criteria: typing.Optional[builtins.str] = None,
    out_post_arn: typing.Optional[builtins.str] = None,
    placement_group_arn: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservation.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ac561edf867860b2e6780f7d06fe916bfb499cbbdab9e47874e784f8ee13259f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b837e3858811127cec4a1a49ef5fbc9c4920b9ca228950a0e8797ab41d9a406(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c78e4680a157e3466009de77e8aa625d8cf7fee8e6f0094ed98d312434e17d0f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__22b368a04915e99dd5744c69aee4e5f18ce694f374f86d57efdd11669b182094(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61255c59c261f39ea55478e744de40ef81c899601741a479966b55964910425d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__77123d0c19c0832f7509cd76b26aa9299b7596606999f89281b470a4f13db290(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__678dbc8559016cf13cc067fc0b1a2efbca67b43c58a19ad6cb861f9f92eaffde(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4cb6531edd4f2f2d84580cab98baebb9524704a86fe4420ac1fedab59c3f11a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ab7a3bc671d2cc1cbe9b8533b6cf3f81fbcdd7c629787d6fbcf162a2f7991b9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e71563d063a54b01a1641ea15d2304c47a9442638bf103f23bb2279e72a805b0(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f474d13d66628cd099f8b6e63a960fb1e11e349a6e30dd4bcea58da40fde501a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a8dbcf49c490eda04d32bf6b351f510a5d071b5754a19fa2c2b95c6ce0c22f0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__16fa52eb55faf78ebc17e0e8d27a241715110e3c4255fe91c5b59c36ac83d329(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2d4ed674b30189cbf7b11b79e68ea556b2b7c9921a4d61f7610b58d25fed8ca(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservation.TagSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__26e29c48a6cb47934fcf7b54e3d3eed16da0c88c8d717089ac043c03ebac0b5b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__578daf872c6424406c4ac67bfb16e1a373fb40f41078950b64a62c991d0be846(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6fb1af1f639a354aff6bb978bcac42ab042448e257770c8bed7a46897429542(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    allocation_strategy: typing.Optional[builtins.str] = None,
    end_date: typing.Optional[builtins.str] = None,
    instance_match_criteria: typing.Optional[builtins.str] = None,
    instance_type_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.InstanceTypeSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    no_remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
    total_target_capacity: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35bd03d12bd6116122e660dadd70f4c4735a841ce1b9a702a966cfc70b2123d1(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12b0be9e7203b7b337996367bda0b1ef3d17273516ce9a44f5f9c1be5c34c081(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff7425d803e147608940b2d4d46fa62c8f6d398dfda2f81c4d9daae76caa17bc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9be4232e54cc46f4b116770555b9dd460cb1f802b7496077e8e31ba3afd7cbff(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__026984f5fc35753acd6fb74696c8208736dc28838b389118f458535c5762a672(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45208597646253fe188d8f1f2e5d2fa3ecdd988899be6ea30229a2132738df76(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.InstanceTypeSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a98456c361af7e60a4e64d845a4bbe28b249e03540ffe9d59f96245e0f292752(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cfebbe0400b084370b4e45e01a83c61bb47ae01d37c14a2ac6591c4708c975a(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9be24701036c5abd754bc67058ec4d8c733250163e5a63577648325991d133e9(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnCapacityReservationFleet.TagSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7dbdd25c7a6e3e88f44f955dc9784e01a01af6c00df012edb23a78014e0caae4(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b98cc8f5cd84b2ab7c2779d1b5d483afac7074f27afc44e507d761ee2987489d(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f03a957255637b5857219e572d51eadfa10b8ad587bd37cf340d9e7c2231d21(
    *,
    availability_zone: typing.Optional[builtins.str] = None,
    availability_zone_id: typing.Optional[builtins.str] = None,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    instance_platform: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[builtins.str] = None,
    priority: typing.Optional[jsii.Number] = None,
    weight: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2494957f49f85b50a915390ad0dfbf5c119ba87d5b7f2a04a0d67766b4901d34(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__43bd0a52cfe7402bf156151a3e760ed1bd133935bd29982a3798f854cbee5064(
    *,
    allocation_strategy: typing.Optional[builtins.str] = None,
    end_date: typing.Optional[builtins.str] = None,
    instance_match_criteria: typing.Optional[builtins.str] = None,
    instance_type_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.InstanceTypeSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    no_remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    remove_end_date: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservationFleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
    total_target_capacity: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a65d4e8bb2e678a9a6387fd809c3b5428c783211224ece5155ec92d1eda301d(
    *,
    availability_zone: builtins.str,
    instance_count: jsii.Number,
    instance_platform: builtins.str,
    instance_type: builtins.str,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    end_date: typing.Optional[builtins.str] = None,
    end_date_type: typing.Optional[builtins.str] = None,
    ephemeral_storage: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    instance_match_criteria: typing.Optional[builtins.str] = None,
    out_post_arn: typing.Optional[builtins.str] = None,
    placement_group_arn: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityReservation.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a96681cf286606ecadca18bda0ea89ce2bcb5ccb239c0ee8192648a3c637a8b7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d13b490de5a71d5c115db0ab3676eac3623d858382e7bda0f72126bd9502de90(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__90ea968688bd5c8f89a44e36535e084f93c6f71eba72008a7c8fae86793c0259(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ebb550f90f423a1cfb12d6962e0d7086e672a69ebc839b263de830334bc029ed(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0dfc5813551a9e82e5f55d72a506cf1c303b862a6feb2c37161876bb3709f183(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3bbc37c06b02209086fba1b3fa469d662917ffbfa06787d6aa230add064812b5(
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd74bb129f8a2ee17c8ff18f5e8a8159b69611f04a07a0ba8d4ee6559e6cdcf1(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    client_vpn_endpoint_id: builtins.str,
    target_network_cidr: builtins.str,
    access_group_id: typing.Optional[builtins.str] = None,
    authorize_all_groups: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d12a489bd88f39a7168ebfe201bff6cf3289493f7b5afa2b2922bc47aa6c2c68(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3c2c11aee50519461eefce28d36cb3da24e82c98ec6ae92b06453da946e1d378(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50e6d04c1e7523cd5b1e3a8aa7e8300bd0269bc5af9b74b075b07f8a571ee275(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__56d17686cc15e94936303baff8d4eedc73db3f1a2eeb09ce0187cc9c3009b3fa(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6e18292fe4463a8537a7530cceaa1f4005c5deba7137c98197919623660f02c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__23a4fad72febaec5f7897b0f2d2dc6091bb1118a92f232e90857a191a9149282(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a0b70f87d13c22c58248897e96db8448f527f13ea896b4d14ed47955f79b9e3(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1cce0b54049d26d96ca01a40dc238215d295ed1ab60e488a987cb2bafe1a791(
    *,
    client_vpn_endpoint_id: builtins.str,
    target_network_cidr: builtins.str,
    access_group_id: typing.Optional[builtins.str] = None,
    authorize_all_groups: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1880bffa9253aaedfa6af6175da6262a96ea34dadf82dc678a1eef91cb7b92f0(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    authentication_options: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
    client_cidr_block: builtins.str,
    connection_log_options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ConnectionLogOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
    server_certificate_arn: builtins.str,
    client_connect_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    client_login_banner_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    client_route_monitoring_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    self_service_portal: typing.Optional[builtins.str] = None,
    session_timeout_hours: typing.Optional[jsii.Number] = None,
    split_tunnel: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    transport_protocol: typing.Optional[builtins.str] = None,
    vpc_id: typing.Optional[builtins.str] = None,
    vpn_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6c918e848a5790bf428aae5434bdf054890599ff5e33a0c7aec91388a7d88962(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4840c2bcc0e38eb5b8ab1bf4318bcc826fafc75f0b1a0d4b4af2671fd548551b(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8fd721536b7af569ca4dd0cf5d6d3e5a4af03f14f0a211dca122f2c1ac5297c8(
    value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientAuthenticationRequestProperty]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c82ca35d7edd1869a3d83867786684f955e85c4ac53303d02ebbdd382476bc11(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18d2e85936305e18045946d27a2644a466c3e1398c55ace117c923d19e4e239f(
    value: typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ConnectionLogOptionsProperty],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2bd127fecac421e3bc066a629699ad50c84a77153f1ec4f5626641e6e71005ba(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ff43378f198f2e58416acaccf8cc15978b8057d3e692a315efe9a325e263a4f(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientConnectOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__497c1bea9e9caa987aeafc2d4334f07cd2d9664a3f3cd38bebd5611705a992a0(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__256286aa73ef76d9e8c01586acd7784d241671a2785ad66bbabd4271eef9d823(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bb1d5fb0102c1b6de24ad13acfc13837ec5422291e23048395fe03350aea2188(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ebcac79eb30395bbcc38271559390a74d75a7ae45dfe368c2cd3b996b81b462(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__579de23f23e1dd217e8431defd11b303d19733349907433779f8a626aae9cde9(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8906bf30210d5bc2dc8408899f5ca0117189261f028b77c92f7388e86156315c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__794dd5b3de3a1c6a9d4c9dab081dbf25f0c2c05274d74b3e4fc01f8b17001d25(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d96887217ae5515add2cb3a59126e1d0cd39a226e9816afa37568bc70cb2f61(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cc170770bc9adc8648a63b630961b275859df1f9019415667b679b2cf764d8eb(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnClientVpnEndpoint.TagSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7606d3932bdd042643cd05946ce9c33ae761b0b43aa601cec4d7639cdf467b12(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__10f3125d05aba06539b785430760a1829e6fb47f55d9a88648888bf1727da9f5(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__662eb5a92b0bd04e8bb4b264778b748b7e43ac948946096053c568d8b911e105(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cc37b569930b5db9e1e89a2936bbf73c15c41b1fc566455e26a96a67b711362a(
    *,
    client_root_certificate_chain_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93d4b5bf25c558dd4e4b4bbec8493db5e9a168f9b8327c99f3b48709b29f0305(
    *,
    type: builtins.str,
    active_directory: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.DirectoryServiceAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    federated_authentication: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.FederatedAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    mutual_authentication: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.CertificateAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c807bc6c81e334e361f85e32e4442141132b4ee3c4bacdaed8cf79b617caaa57(
    *,
    enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
    lambda_function_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__907ff3a3bd097ac37a720bbc18cf4e29748beb226ddf13641e48350162da19d3(
    *,
    enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
    banner_text: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a95e90764e53fffb06a3e0dcecbd41f642f3362128769eb65cf04e24be9cd71b(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c142e5322bb8bda4ace9616736c0e12d7c7b9b219932b4168a975e68d0d9395(
    *,
    enabled: typing.Union[builtins.bool, _IResolvable_da3f097b],
    cloudwatch_log_group: typing.Optional[builtins.str] = None,
    cloudwatch_log_stream: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6fc687dd9d11c39776770388c8bde0ccd238cd37eb50b3855604baa114f8fcc(
    *,
    directory_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d301df1b88110c542331637189053fa067891656efcdcce073dea638050e816(
    *,
    saml_provider_arn: builtins.str,
    self_service_saml_provider_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7fadda101a8454212efac8a224e66b4af09c2e630eb4772396408c19bf7444d1(
    *,
    resource_type: builtins.str,
    tags: typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__05994467e800c33b4a01e884b4b20bef2569d710f5dc323617cd814e50e5bdb5(
    *,
    authentication_options: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientAuthenticationRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
    client_cidr_block: builtins.str,
    connection_log_options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ConnectionLogOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
    server_certificate_arn: builtins.str,
    client_connect_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    client_login_banner_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientLoginBannerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    client_route_monitoring_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.ClientRouteMonitoringOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    self_service_portal: typing.Optional[builtins.str] = None,
    session_timeout_hours: typing.Optional[jsii.Number] = None,
    split_tunnel: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnClientVpnEndpoint.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    transport_protocol: typing.Optional[builtins.str] = None,
    vpc_id: typing.Optional[builtins.str] = None,
    vpn_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3dfb737204851cc06c49c2c8a2089a474e3c7ab8c9522c2b17a1cda4e8d4e6d9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    client_vpn_endpoint_id: builtins.str,
    destination_cidr_block: builtins.str,
    target_vpc_subnet_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ebdf42d79ea0b48b9768a7f69f6f849b67a9aceb079a45fd50f96be6327e5155(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3f633fca54521e752c1bc7455f2ac48bbea65e9b27b2cea6b3fcf87f8910a12(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87c23fa81bc76240c6ce4c869a804c37228a002dc52b52a37dfc6164270825b1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e47d9f8cb47cf5a3263b2bb98b9ce1cc75c52af2f813f0966d8d270ea841ec3b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__512be83797e2ddde08781d1160b36d983c2af081515532f8e3bb0689d136cfb4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b10f6f91046363ff96a4de67abb063cdae0418c01d141e45220d29a8a6c8d3a8(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__04e293f5c6f16213a7dc895687cc68d3defb2606f9d9e24c82d8f28fab9a0c49(
    *,
    client_vpn_endpoint_id: builtins.str,
    destination_cidr_block: builtins.str,
    target_vpc_subnet_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3246cdc0c4c45c3bb7ca145721849485de3058412b28e18e6a2521dee9feba7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    client_vpn_endpoint_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__328449dbe5f58a7132b6b6b1ba468f97ad09c68f19c7763fd188cb55dd0a50c3(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ce31eae78612f60b70ab52b2bb1a8bfb8da40aed559073873834454e4009da2(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__256c01852f9be0828ae3a474428434d9bcf06b1f2f38dd2cf5ff3440f4f4a5c4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74bdd32493a6798a704c13cb4090daafbc17fc71b0f7e4b1dd8a078962344e35(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__121d2c21f06ef1b4efdedfd8846bc605f91f3db0cc9c2844409f378474c9b397(
    *,
    client_vpn_endpoint_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__16b41182e007e05b84fd0c97afc1e26001e78a56de2eb5b10c9f809de0654b0d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    bgp_asn: jsii.Number,
    ip_address: builtins.str,
    type: builtins.str,
    device_name: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce54eac1ec957fc55ffb27a654680402c3468f669a41d23ab734690d410698df(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a44104c4ad329cfdabba2866cf426d821fa85ba6f3aa04801988c746bd8ddad9(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84dfb7d1775bd2bb124f990570c9a2ef23fafd01744cfe248fcb360562f57ca9(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a312c99e6832f0396cbd7c4d05fbab836db0503cf37ecee5f1f64bd213516c2e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae973d5ca9904c069d03cbf10a1e3fdf7736cc00ca43663eb07598f97c4e5771(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71d74664cf79e34328f5f6958fdd674c45b2780c9910dd252b7c5e9caba963f0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__05a111d13df5583de4721245805f1cb23e3c81e0e12774d2a044cf75bba55873(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b0ef9a2e3e2b6937b21db500a1cd795126e924d9b920931a413ecdb668bfc7ec(
    *,
    bgp_asn: jsii.Number,
    ip_address: builtins.str,
    type: builtins.str,
    device_name: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f22238da23e1a95528fc55d3e3a28b661b69a5dfe2d1e64620bef1ebd86deca(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    domain_name: typing.Optional[builtins.str] = None,
    domain_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    netbios_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    netbios_node_type: typing.Optional[jsii.Number] = None,
    ntp_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4bd34186ec5701fad199396bd872adb91c15f71647beefe007bb9dbafe17d86b(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4b6b354957e45d57a7d74c91d58645803e6d3b3dc74c069422742dd52f73de0(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ef924b0a20b9413b973ce7cba216c31e794568c9f99a083b994d3e69ebb3c5e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9ee8e87c9581893159e005c5c7c786324d9f9c9a41ba0af4f72aedd3a9903ae(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3b8e4bd8f79a27f01b9c18995f6a45e13c80f3ff9f392b3c558b6cc5a5e5dba(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72bd8121cf33b33a52103c326c339f9ce10fbb12df0d71f411557aa642a9c385(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__183fd1ef6a4ee905fe372ccc2f27b5ba3a48f856c21c3c678eb1b4db43bd1ab9(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f4c459d5f98dbe6bf3fd3f9f7fca2823e7ee9510398ee1206c9aa28765f1d61c(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__569097ad87e4dddbcfaee4fb50fc7ddb345c4f97ae82fcf897497039e7f81a38(
    *,
    domain_name: typing.Optional[builtins.str] = None,
    domain_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    netbios_name_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    netbios_node_type: typing.Optional[jsii.Number] = None,
    ntp_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b04bc874649f768ee829fef298c1c886ebb6fc5aa454a0c698e17c25fc9b40f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    launch_template_configs: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
    target_capacity_specification: typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TargetCapacitySpecificationRequestProperty, typing.Dict[builtins.str, typing.Any]]],
    context: typing.Optional[builtins.str] = None,
    excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
    on_demand_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.OnDemandOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.SpotOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    type: typing.Optional[builtins.str] = None,
    valid_from: typing.Optional[builtins.str] = None,
    valid_until: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba2b8151d12fc4a02b9b697317595ccdcf5010cff290619525b157c76a9376e5(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__232ae85cfe3baeed9d41ac592afd4aeecf1a0032e258e71efca09cf806f2edcd(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11e66fc2296b61712f860ba32f7e4f6bae1d4caa8477ebd1d0e90496b03d47cb(
    value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__308e9c06cb8e557e27da19507947b7edd3a3aadc38cdcddcdcc835402d1fdce7(
    value: typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TargetCapacitySpecificationRequestProperty],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14055459b56a2936b7e5b3328bd76b98c965834cbec37d83a630495b8e9a8de1(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76724f7a5d1a753ad3d973f4e918523326a8dd12f7c437da5af31418195c7222(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__387749e6f1f8ee96abed2de0d2312d91522d94f22e7c4625726360add11b93e4(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.OnDemandOptionsRequestProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__123332aa6b3b1e5b8f117ed3c89fbd1dc4fd57833234901707c819d14f66fe50(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f056b97eccf2fbd77e6683adf7ef1aeb7b2afb2329fde0d2d6cfb1b273233bea(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.SpotOptionsRequestProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bece0741240e27126cb8a337d5fce1c6a45094b66f86472a241f9f7432e40a77(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnEC2Fleet.TagSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0bd5baf142838966e793088318ff6c3b289335c1b15d0d9e87f74507d42d74df(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__59a50ca71a49c9d182b71322c445a4ba7d65a775570ca036914db2bb21276e74(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0dbca3955ea50bceaf0d75c83c574fa2b09d61b437759776878b29bf18cf1db8(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2d545dba13e879cf198f83427ce9f9f5071d32955fc00fa93ec5feaa00d5a36c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc7b29adcb33628864e03a448dfeb55fe20e548d25b6d9dcc6fabe20e73cfe20(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12d4abfc68e759d9e5357219f5f252e61b8f61a3e63ec616b710599588d562e0(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e0a4de467a89057f40232d0ebf30c0027feeac4eb5957e8b9a24d27f33ef59ce(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c9644ecfacce71230069287c64c15045d2faa220f98ae11e6e91993204231d1(
    *,
    replacement_strategy: typing.Optional[builtins.str] = None,
    termination_delay: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e503851d3968a25a6118b10e016d02c1a13b189fe5c588615ad2269d37a9b9b(
    *,
    usage_strategy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a16391ac858f174f4e714e8b72b94e7e61e1b50ead8e638dff708e3d739752d5(
    *,
    launch_template_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d758750d188cce1b749f19591d20310ad5bc697f0e6f94f495c9619297998763(
    *,
    availability_zone: typing.Optional[builtins.str] = None,
    instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.InstanceRequirementsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_type: typing.Optional[builtins.str] = None,
    max_price: typing.Optional[builtins.str] = None,
    placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.PlacementProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    priority: typing.Optional[jsii.Number] = None,
    subnet_id: typing.Optional[builtins.str] = None,
    weighted_capacity: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d89df5a41143fa7395201e459ee2a2dbb7ec441738ee1a58eac3f6d95e953971(
    *,
    version: builtins.str,
    launch_template_id: typing.Optional[builtins.str] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5fc35aff5e96972c3cf7c89fef75da6adc5eb146fd5504925579235a4de6e0a(
    *,
    accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.AcceleratorCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.AcceleratorTotalMemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    bare_metal: typing.Optional[builtins.str] = None,
    baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.BaselineEbsBandwidthMbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    burstable_performance: typing.Optional[builtins.str] = None,
    cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
    local_storage: typing.Optional[builtins.str] = None,
    local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.MemoryGiBPerVCpuRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.MemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.NetworkBandwidthGbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.NetworkInterfaceCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TotalLocalStorageGBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.VCpuCountRangeRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74a54f8579657c5e4deb0c052567cd4660664c3fcc6d9232bbc646b1ee0c421e(
    *,
    capacity_rebalance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.CapacityRebalanceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b60bc2d12a913968d0d316eb200c86e5d9ecf567ed9b6c6e51cdbd1a0b417422(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__582bf0e6109937779c349eb63366e7e4cdaa15b4c199c2ec484777174cd8b7d4(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1631d95b133eba9c84f539d999721b9029fe1ac10dad3c41c3cf7362e6dcf23(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1c61f48589be52f9f062634b2e52fcd4095fcad95dc9fd0bf2a68bdfe2d9829(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dce716d2e517f4e8c297cb02cd9e5e88232758cb9732040686bdfb59b38c71c3(
    *,
    allocation_strategy: typing.Optional[builtins.str] = None,
    capacity_reservation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.CapacityReservationOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_total_price: typing.Optional[builtins.str] = None,
    min_target_capacity: typing.Optional[jsii.Number] = None,
    single_availability_zone: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    single_instance_type: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28c598518bf40690e18af7409981451456cd4d41d853891f648b55488b7113f5(
    *,
    affinity: typing.Optional[builtins.str] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    group_name: typing.Optional[builtins.str] = None,
    host_id: typing.Optional[builtins.str] = None,
    host_resource_group_arn: typing.Optional[builtins.str] = None,
    partition_number: typing.Optional[jsii.Number] = None,
    spread_domain: typing.Optional[builtins.str] = None,
    tenancy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9673542a949ab3e4b488aaa9dfb67cceabe990e15b2281ccc01f9698538f168(
    *,
    allocation_strategy: typing.Optional[builtins.str] = None,
    instance_interruption_behavior: typing.Optional[builtins.str] = None,
    instance_pools_to_use_count: typing.Optional[jsii.Number] = None,
    maintenance_strategies: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.MaintenanceStrategiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    max_total_price: typing.Optional[builtins.str] = None,
    min_target_capacity: typing.Optional[jsii.Number] = None,
    single_availability_zone: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    single_instance_type: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02540c2eeb5628d16d697845e0771b23c9a778ebfa08c4658341538bee2de664(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ffe51592d5662fcf623b04b7a62a1d91a35fb6ebea29d504ba00fa1b4e924887(
    *,
    total_target_capacity: jsii.Number,
    default_target_capacity_type: typing.Optional[builtins.str] = None,
    on_demand_target_capacity: typing.Optional[jsii.Number] = None,
    spot_target_capacity: typing.Optional[jsii.Number] = None,
    target_capacity_unit_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68dd4f11ba96f8c88ae78d9d9a0bba32f2c60cb68f8364c2a828277864408781(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c97ef3c582df6d6b2c591c98531be161631a53d0b66f66fe471939622e85fdc5(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7cf6835c4eccb4808ebe4e3b9b155d296d115ff66f1472a19acccd9978a85f7e(
    *,
    launch_template_configs: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty, typing.Dict[builtins.str, typing.Any]]]]],
    target_capacity_specification: typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TargetCapacitySpecificationRequestProperty, typing.Dict[builtins.str, typing.Any]]],
    context: typing.Optional[builtins.str] = None,
    excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
    on_demand_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.OnDemandOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.SpotOptionsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    type: typing.Optional[builtins.str] = None,
    valid_from: typing.Optional[builtins.str] = None,
    valid_until: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bccc7dacde749a3ad3c41d116d1f509ffb5b6881668bfa61c205201b19574cf9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    domain: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    network_border_group: typing.Optional[builtins.str] = None,
    public_ipv4_pool: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transfer_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ff25a50366f77a6df3a4ede4ef39917fc3d769d83828726514086b62d179131(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11eb36186f31c4bea4b03f2dbdc66bc726d4347d12b0636ac6aafbdaf0aaddbe(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c49330fba74ade775140567a6ae48812faa62fb21c67fbdd7930ff5cb2189524(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca5d5ea7abaea702ac65d5f9e8401058e42e908ac87dfdbb8722dcb03f673d98(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad1782664068283c33182db79bb89a1f93f451785b0dfd4fedeaf0a308110149(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bf9bd4708b5d85806a12d49dcb54159d4422fd6d4fea47a05f5f00ece5dca5a6(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fbabb7ce878301e495e9c01fb2e1183996e3d3ff9174b1398db7c58a5b47c3d(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__09d9366c0699f2554304df4c739a5801dd39c1ba371b808dcc89894749cd3433(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08efa38e3271575d41d7626b99dd3858f0402a0285c2874241829879f80ad5dc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    allocation_id: typing.Optional[builtins.str] = None,
    eip: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d38ac0f8a89e7add67dbeb5b57090fe5a6fec2abaa2cfa15937784c2f88b46f9(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14b55763d95c0a49faaa7084cf56cd092e1302d037f862850b20fff088532bd2(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a145c0a59ed4b8e109758ede53ea195429ed116afe50bef5519ef1c93ef2f3b9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f947c3656e7fb463745cdd982fbd04fbbd2146e52132e6c3c60b88bbf90d3372(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__15ec06a481e0b7a8566ea8c48543a95bb46df08bdf87da3f3dcba102756d7221(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a3b32138b35250b675dba9ddde0e08a0eb7f077bcd27d5c1bfc7676f3dc799c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0013614294ef24c00fe534d4321fe1657b4fd366c4ea9eccfb2d19b2861d8440(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d7e6118721d9f331f2cfafeff3be65471b4d44c1abf5e5083229fa0bb6ad726c(
    *,
    allocation_id: typing.Optional[builtins.str] = None,
    eip: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff96bcb9544d5ebc6273ac8c518468df0cc1fd7720428f6e4ec85ecddb06fa60(
    *,
    domain: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    network_border_group: typing.Optional[builtins.str] = None,
    public_ipv4_pool: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transfer_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84a7ddca98bd1c24713f12588ec54b51cdc19c99c2209e07c964172011c4d7ab(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3776ca79b4c1077cd8641d4bff766f9377360b8cadb064edee5912829e24521b(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ac2763e5da89e4e1ee6acf841762d6a8bc01d40589085b652b4f5f545c13102(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd41a3676da418b0ac30e8c6707af491b5f32416672bf517e640f6132a942063(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b693b2d49003d73758f4c0003564a93353b18fc97434556a2e988e47f367fb84(
    *,
    vpc_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2d7cc97af7e0281c5467b107a4b4d0bb76b59e1c397161a6fa7d7f0a2a918097(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    certificate_arn: builtins.str,
    role_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__75c5c30f47a18964a08b0e104af0e125e2c6d69d00e53e23a8faba6e7efb2248(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49fde7f75409bd6c3eef1dc479fe288b3ab71c68799ef372073205fdedd03d81(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36a9750ebcb712bef33823ecd48c04b607764f04df094442b80cab92b9d24239(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bebb7fefbc76f390f31133552e945be922a94a4a480afe3ae0490c0dad9a102d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1d46b0b7748b6af77bfec597465bb1c4d453df888f2782e783135feee848f1b(
    *,
    certificate_arn: builtins.str,
    role_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72358d22276e2eb5cd641ca06942afc99075017aabb8f3000a9b07b53750fcdb(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    resource_id: builtins.str,
    resource_type: builtins.str,
    deliver_cross_account_role: typing.Optional[builtins.str] = None,
    deliver_logs_permission_arn: typing.Optional[builtins.str] = None,
    destination_options: typing.Any = None,
    log_destination: typing.Optional[builtins.str] = None,
    log_destination_type: typing.Optional[builtins.str] = None,
    log_format: typing.Optional[builtins.str] = None,
    log_group_name: typing.Optional[builtins.str] = None,
    max_aggregation_interval: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    traffic_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e198443ee858ff19e4aabc024d3248d8cb921d93f5a62465d022de2d8cfa5e2(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6eff7a114e2714334c6df6d1b2e56918a556871696e25a588bf089c4a4ea3f2a(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84e5a2c6ad5e904ca809a2f153ebda2b81c23f9d634700537999ae612f2d8462(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d21f005f9535582c1f46053bf4e82c2bbabff7cded5a69095501539e5f469ff3(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__69de10af6e71879a605a8ff40c4836ff6e89ad4220088a0599668acc26625a53(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b921f8c4adf8ca7781a1e0174a51a4017191049028a6f93859d3f656946c7c3f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49796be537e8b2013810fde10b43929fda215b3a4171af478b31fdb27302d616(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__949d939e627fcdb6a73a2f76769f6cdfb5973630d761825729685b7af98b27f7(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce5094d9224f3fc4ab9de0af2048c5229af2bab60296a1532059c7fd0f35152c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c84872a8fa41e81525525e433ae100f134862fcfaf118eb631c2d92ee89fd88(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d4c0e5979a8d23aa64b8481c35dcd22bd972c3b805f0f16e2bcf9249dd13e78(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__408957857658c91ed4a24dd2c0001b02c4d953a90495ab29b67a8f47d4c8637d(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d5a7fc9ee55af57fe376f2a1925ca134f75de57ffce411d2318f45b1d139b4a(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__648073b4921e181f4252118a3f0bd9e0910cc4a9f11632928884f0d6894061ff(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93145601fe9d5b59646cf267ec0583b6a5749f370d14826d2dc5888efb2826a1(
    *,
    file_format: builtins.str,
    hive_compatible_partitions: typing.Union[builtins.bool, _IResolvable_da3f097b],
    per_hour_partition: typing.Union[builtins.bool, _IResolvable_da3f097b],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b70808589b9adfc66e939b8c87268607775dc0e479da5f4bed72c3ba8e3afef5(
    *,
    resource_id: builtins.str,
    resource_type: builtins.str,
    deliver_cross_account_role: typing.Optional[builtins.str] = None,
    deliver_logs_permission_arn: typing.Optional[builtins.str] = None,
    destination_options: typing.Any = None,
    log_destination: typing.Optional[builtins.str] = None,
    log_destination_type: typing.Optional[builtins.str] = None,
    log_format: typing.Optional[builtins.str] = None,
    log_group_name: typing.Optional[builtins.str] = None,
    max_aggregation_interval: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    traffic_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b6e9c558b84db03ce7f87c5229b1660a182dbcc83eb7b603939ad024b053290(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    gateway_id: builtins.str,
    route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__210fd654bd3dbc467b26765ed18c099ae7b5043c293d926cade19fd3802bd80f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b18f652516d55efdc0bbaf9e0aed3e5e7b9ed6a627018605ad3a8ac40bcfb08(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b80b9e3979b7f3bc56f10b10d915c83ac792f4ea63ad245c84317b275a65523d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9de1cff2e9acdaccf461af9bb29e1e72246de3e47124324639ada6d2b19a81f4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__17bdeaef71282588c502b071ec9708033fec42cd59c61e718eb5899520703999(
    *,
    gateway_id: builtins.str,
    route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3a07acffdb551edbc817b7c424628c812f21356d7f697757a332323f6dcfde8(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    asset_id: typing.Optional[builtins.str] = None,
    auto_placement: typing.Optional[builtins.str] = None,
    host_maintenance: typing.Optional[builtins.str] = None,
    host_recovery: typing.Optional[builtins.str] = None,
    instance_family: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[builtins.str] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62948130163263864ea13dc24c244d1ba844fcdcbf6e72536422cfe1f035d0ae(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f6d598529fd0d16119fff477306582a339f6d734027d9e85531c72b90654a41(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8f2943fd7038584c6a32abc7ac0a93f4b0f4c63881cfa72150bd73ada16642d0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ef92a5203275a4f9d2ce9835a43f6cd82cac31cb59c1d0ce172cbfc9e50fbefb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__847519b23588450ab8d14c5778b80f32cdf5fa3f1ca8c772c0b129d3a9ad3c32(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5da78a5d765050694e66dbb10d6bc046deaee511071b83699b9f3c2f2816c2b9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b92e78abd69ef3031b103aed1c9826c3000239f5d58022c4cb1dd256f65a8da9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__17d80a761d1af3dea3988a895a0ef398f8f899481397c0e52127d20797de751e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c99a5cb989b1890ba7a9c45d3bf3f171871e622316f2e23f45489e55fae7586(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1e93e24d3ea88403b39f7d948c7495b074446c1b676d25cd60fc9a3a558e7f36(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6b2753a5bf48a7bda574bdc6bf8ca7f9c31c7e48329df5f793f75cfb822ea308(
    *,
    availability_zone: builtins.str,
    asset_id: typing.Optional[builtins.str] = None,
    auto_placement: typing.Optional[builtins.str] = None,
    host_maintenance: typing.Optional[builtins.str] = None,
    host_recovery: typing.Optional[builtins.str] = None,
    instance_family: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[builtins.str] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5dd8d015864426e689ac2f72f1fdd70371d242931964ab4d571ea56017f00045(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAM.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    tier: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52d60de86ca7ba70a9845a22c132a50b0a472c7cce8b00d8e266f850b9c0e6f4(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__901ef9223e06c12f769b4bd36857fd88adae614a05385d54a0dd6f535824d002(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__959c716c17871ad25c09c928583239d9973366c81c48b69bfc39c5c2a70898ce(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fecbb17dcfafe289f5a442dc3b73f564f5de07433cc7e26b8e86425af382451f(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAM.IpamOperatingRegionProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e1f584e5fc1ac961e5449d71a22aa5c200ae3632e3bd5a9caba51ea5d38dde7(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c8cecf24bfc36bfa727b2bcc8526f504fce30463cb6dcc5d49d5b9d67749d5e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76ae7ea9478fca86299eafd84b20c22db0b753cea0096278a3be708fdccb0c7d(
    *,
    region_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea7a8d7dc762f36c7c42acf390ff33a5d901404e11e9316d7df8d7c29c9e6af0(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ipam_pool_id: builtins.str,
    cidr: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ba0f7e823a6d4a60a4cb169b078ea9c23b3c54c729c78632914b49c5f2a4751(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad213757c25805fb10120b0939b5a219ff19cbe5f92a4728e9e1a0444c5c64dd(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__64e2f4cf4e3421886a498bb9e45ea019547a5f8e087690bbefc7fcea3586b903(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b2e8a509e9710e3df3c5cdd45c6611dddda58579bcf820e4d97bf9783fc86238(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae562f8439586f83a0987704d36755f7df5f4a7e5c8e2420a6f2a05dd208d415(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d9043b9cb409d41dda6d6f1b1ac81fccb06180f67f05749e5d26225f4844545(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f074bee976b182b3e6932081b7e2343fe058af055ef039867eee673737cd6914(
    *,
    ipam_pool_id: builtins.str,
    cidr: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49ac69dacc9e55c18363e598ee436fae30723dd4b487a4cd51477854696d9739(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    address_family: builtins.str,
    ipam_scope_id: builtins.str,
    allocation_default_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_max_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_min_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_resource_tags: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    auto_import: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    aws_service: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    locale: typing.Optional[builtins.str] = None,
    provisioned_cidrs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.ProvisionedCidrProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    public_ip_source: typing.Optional[builtins.str] = None,
    publicly_advertisable: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    source_ipam_pool_id: typing.Optional[builtins.str] = None,
    source_resource: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.SourceResourceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed624bf3dc307f04a3b45acad98bea6483b1a66eab0f2a9472fa9843d91564b2(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e7676e43df5cfe9b5768db72cf66c10335a772ff51e6a339deb5179a8979067(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a5b241c251a5a66afb68207fac43059c8a2515b97d3b1cc207e2657902e71b1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fbdbec1bdf539bf7935f66283de5d2455b37fd036bd5f6e2f5ad52c42338fb1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bb67e5df586c19b16abaf86994738112eed024ce90016e4c18b7dd264553f702(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ff43fa5869f5613ca15882015827b8534dcb8488bc50fe83a2d7974080f5420(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__841766c7de2c1b457f6e90e16e2c5de9d9ad55f57131bf4ebe7e22c651a5871a(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00c43e28a217efdf34866f8f436e0d615b3f76ef33d75a0fcd54107f4fcd2395(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, _CfnTag_f6864754]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3bef013417f7aecffe6df419f044a34ba6c1056e4c6fe41fab3f61c1c98629e(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e466f53a7750a1bd0f9875419a5a1b56600ca1c8fc7f153ecaab870fc5b5876(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bcec51b995a93f9fe674b9eb0c8ec907bb474c040116a93fcfe16794efc35e8b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f634bcf807180517176b75391374db468661710cf7172f3ee46b626259a33de(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2ec724b5a099431c168859f8bae8690b6942bf2c4428928ba37a452bf8eab6a(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.ProvisionedCidrProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67c2537c8cc935adffb5c8b6b1f780d4d25f1c3bcead923fd22423ccb9eff737(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a2c1d055ef4dd3ab27084865a5b4dc034dc0c587c1cfc2aef7e63cafc581793c(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__324d3ea5d3ecf303ca16390cb4f68ab2b30fc3cd3cf7c82ba59c99a16243a68b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3f70db41696848da5f2c3703ae0a09b95494dc9b1ba1e9e1147650712c765d52(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnIPAMPool.SourceResourceProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5a27f882c280937fa0881f1d5fdc26d072d6a34ae1cdbaec63936d887ba4555(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fff1e35b565a960234fe5a7c634cdd72887d66cc483af55f294c6fc9ca10476d(
    *,
    cidr: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__499a6dc3aca0b20e81b7aa4c45945c37a69bc00be56b64d258b95bd99e3d3db8(
    *,
    resource_id: builtins.str,
    resource_owner: builtins.str,
    resource_region: builtins.str,
    resource_type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8784d64f2ed9d5c5895a39ee2f303c65f7cbf35f09f8eb6a6e590f7adcf217be(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ipam_pool_id: builtins.str,
    cidr: typing.Optional[builtins.str] = None,
    netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67f4fbe564d6d7617267d90115cf76c866b19ef78aac34898ab34a9b389d9f70(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0e5bee11f6dc0a79c374293f45edd7e710b263b2f05a59e64a11d3fe5e48cc69(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__604012fe0368b158338f3d6974a78e5e58e5c236b6ab4115d040a7eb4ecc1ce0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bf90b94d3e69aac519821a92155ed9c530ab8f3c04676ea35a1bce7b5e4d5674(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32ded8ef5c4803ee43c7716ccda0fe7c6c3490433df2a1a6d618465414541ad1(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdded95565386b2554341a7bf1237ba2394f4be9ae7bba368c7bfe4909dc0f09(
    *,
    ipam_pool_id: builtins.str,
    cidr: typing.Optional[builtins.str] = None,
    netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c42f207097d7881d4b52878ebd2ec0ae90f2bf68e18d515c40977733d8d9b124(
    *,
    address_family: builtins.str,
    ipam_scope_id: builtins.str,
    allocation_default_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_max_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_min_netmask_length: typing.Optional[jsii.Number] = None,
    allocation_resource_tags: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    auto_import: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    aws_service: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    locale: typing.Optional[builtins.str] = None,
    provisioned_cidrs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.ProvisionedCidrProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    public_ip_source: typing.Optional[builtins.str] = None,
    publicly_advertisable: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    source_ipam_pool_id: typing.Optional[builtins.str] = None,
    source_resource: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMPool.SourceResourceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1252b3f41198f9c0d9b0c751334626e1084e0106d3be9d92d77200730b95e90(
    *,
    description: typing.Optional[builtins.str] = None,
    operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAM.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    tier: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b9865e76fdfd7caecfedb4df232a297c92dc11c534785272c111c4d0ba492cfd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMResourceDiscovery.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1d8c82f3dfe9b8619160b061cf8b66f8028c4b53cd00fc8313e6ceec44d1e6b(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c37f9297c88eb6473630fb8466d9077db4b53894926c42cdba143b510e3e6711(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__639c336864ab565a700853f71e9677e8bfaa918f3f432f4b43f243b7579647b2(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08b5ef93b946df5cb347a5d9e125f158c9a540a9ac51f8d045f6c39510e73a00(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnIPAMResourceDiscovery.IpamOperatingRegionProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e5af2028bd620ac6af11e15ae308dbbee822aa725e6ce8b9b68acafc97810a0(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fffd1bd7ad0ffb1481907684f9ea6caa474483fe9be95e99ef7b5bd42d761e4e(
    *,
    region_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd4a98893481afc827d51d87886f223e1b30f0a19b4c90a338e76e2be3699926(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ipam_id: builtins.str,
    ipam_resource_discovery_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5d646cf54c4b619a5fd65d31cad194a8f982e5f38dfb0cf292dfad80fee1a230(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5951c60c7996eb2fc43622794faab197c29acd8a3e97dc08cead3a0a5a90617f(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__80ac0a63190b6b72f9c08f4e9f0385b95f34cd13976099a905c32fc72b026673(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__931c3839652bb78ab222d06df9528610f9555016f5ff9eac39dff5cf4121e59b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6375db80366aea82179422e8233a2b6fa062438e1066f47a1a85e8f62d5ee914(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb361397fe1ad5d7ac1eae95f3c6ef9c0ab8eb533a0492e48d2544ac255d9a84(
    *,
    ipam_id: builtins.str,
    ipam_resource_discovery_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f109dd2c7d7c94b25622dd13433c13abb153fa5092da9272630e94ba4005e9e2(
    *,
    description: typing.Optional[builtins.str] = None,
    operating_regions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnIPAMResourceDiscovery.IpamOperatingRegionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0261d3b2f94da048fb1c8fbab861a99b9ba787a6bfde7f2b8d1f37d939f92ebc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ipam_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__33ce1a601432c36a76445a195729508d4810ba6d52ceb4763cb3fd1abcb95a13(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3cd844c7f08104cfc38ec0de8271330db006d54de894a5aecb4b5df4be23d9a4(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a137849a9414fb5992c1c8ec89ee6f38207de6759ce6e114997836c7bb0d5224(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5e625dceaf4a24f11f92d07008100ff002df387ed10ce5325c3ecc3a808d1a2(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__360b636f6d0ffe468b2eece7c5abcc5b35a5f65fe82b521469bd1343e359042b(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e05ab093185baf1469a05b4c1ff6279a87a1d8d1be6a9625a64b495f21874f24(
    *,
    ipam_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4a16bcac45df35102107cab13dbaea279aac225408d8ffe54a341484e92c7db(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    additional_info: typing.Optional[builtins.str] = None,
    affinity: typing.Optional[builtins.str] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CpuOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CreditSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticGpuSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticInferenceAcceleratorProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.EnclaveOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.HibernationOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    host_id: typing.Optional[builtins.str] = None,
    host_resource_group_arn: typing.Optional[builtins.str] = None,
    iam_instance_profile: typing.Optional[builtins.str] = None,
    image_id: typing.Optional[builtins.str] = None,
    instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[builtins.str] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    kernel_id: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    launch_template: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LaunchTemplateSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LicenseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    monitoring: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.NetworkInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    placement_group_name: typing.Optional[builtins.str] = None,
    private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.PrivateDnsNameOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    propagate_tags_to_volume_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ramdisk_id: typing.Optional[builtins.str] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ssm_associations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.SsmAssociationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    subnet_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[builtins.str] = None,
    volumes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.VolumeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0f05b7732316f828754605c3154cbf0ccd005a66cccda9fe936bd6d833ff8d6(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85b8979157afc2218535ae732d6c76f3ef2ed9f6e1bfca4fb82fc41d1c824981(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87e90f9accfae6c3bbba01423ffc099c7fec4f1ba15653c6765614277a901683(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1ae241269dda91526f67dbe13022238c1375289dc9d01f92d085bee3e800112(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3925e50c070f64377e9a34e2cda7a4641467c01b8d42f1d691a657f2d5c5fe13(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__042c9c27e1e37cd7271cb5ae943c9a8c073af042fccac0055a0cc2ef934600c4(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.BlockDeviceMappingProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cbc71a85ca64051e0a3d92cceea1b162cbd10827aecc7ee6cbe1a4894f804f49(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CpuOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba159afaa93d1cfa03142545ac6c2fc45b8a873b18cbafacb05e03232921f72f(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.CreditSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fe5e9e392f3feb0f4a077cd9f8e5c6a41b3e32b4e827ada98d41629c5c0e3476(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1e115e37b678459d0e4b676dbfec5f9ff8d4ef38f062cb82724d09d3ed19e378(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8f036dcb6edd2c56f6b2a21215980a3ab4ec3d06dc0bc3ae5a1d45dc2eebda93(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticGpuSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00f9dd3f9cef8f4d1d69547f4ca18f4f301df8477a197bf754b9ca0af4488009(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.ElasticInferenceAcceleratorProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7958686f1c567225ae7cc8d2ccee36dfef9a479396391ee1ff2f65f1d29e27da(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.EnclaveOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48dff62efe0ddb66f23842a25532fe4bb39c9bab8f8315467e234d6ddd6ea5d6(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.HibernationOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1df2bec42892b2e3246b2f3fa638eff1aec0b1c94ecf49227f090b0a0ee3695d(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f600392e6229a8a280df02b144c760ceafc21ffbd5e40af6d0c6454734c69e2(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b113f4afc1e19b58666c23839c1aeca48a39a1726f5969c0a2904f6dbc642e4(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__792c60e584d269c734eafdde6ac59c5e48d8d397a6c64c1ff02a7432401c0c86(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__de1eb323a410b41bd5747356127172e6eb92c0513303e39ab842275271ac4beb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d036709eb1e4dae59f293a3840ac6d3d1bd738fc68ac65984c721a25ec275a3(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51667b6f819a586cf3b104b3b1ef74435861fdf7fb92c3c78035abbe9b31bd0a(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f309ef468fcaf7376083a9aeafea7463099a28d3ebdff9ba4f7938131d14215(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.InstanceIpv6AddressProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6c3bcf0d33bd1fece9e30b9f9c9576f9c02d615eb5b0b3de5f8e2fa25dc40c22(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7275a8c334430bc87a69288a681675c1b8cefd440667eb9193e60dfe3aa6afc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00bc577e0b8cf9dbe1398dc08451a7bd5d8e5d031d9d347f5556526acdca0223(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.LaunchTemplateSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cc2686e45ed4c6d1878a8ae7e28861e3db1d532776cefb8db34c5911f65e2d55(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.LicenseSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7a0da44bb62f454316060622acd522d46ed58c088bae4a9f6249bcf6deca5588(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4cf49de28342f59b82e13651c3b5628d995d1e2dbe8f2e21bb504f69ebdc26a5(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.NetworkInterfaceProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b94a126a071c508f79ee90f5bf58c4128b01fe4e85c97c2a9111f0fd16fdbd4(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__947893fdfa4f834f21c670b592c49513bfa62e60013396a6b131adbcf5435dab(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnInstance.PrivateDnsNameOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a71c1eafde77ef22d4765745762298efe1282a9aa3a65f7cb6bc5a4c165737ca(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52cd42f76a076dc5b64b6059fc467932a0c45b25e4dc8b2a9df576afb335c6c2(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__98b3ddcbbd89e8e3e1c57e918909b07082ecf9f399f352e21233109f94a89075(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af0862bdb0b54ae68c63c8124fe2ae266f1335a875481becee1c43581305f1e0(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f5a0dbe34c0acf2c2660c25061489182d68db16e1d429f2ea8bdb5521b220f3(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fddd8e271a5110ba1fe75e660e4da015fcfa5fed134753a58b9f68cd018766d5(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f9a32550ddec52f1ba6a992df03aa6816270d379d0f512794e98b8d156f85a8c(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.SsmAssociationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a62860fe29b6cb930a52f9295a28b9df24db9cb25b32334e42614ebcac2f918(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__03dfed2deae633759b409b545f5453f346f2bf97eabae0ec113f7acd20af0fd1(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__04e99bf6ef2dde2a2e74e30ed9457bf21f79ada0defb8c84b9ebff315eb8dc35(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8de558a59f9ec82f3fa87617c25ee9a0bbc302798e4bd35a548582053038e283(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e4c1329311f5d2e00f32bad89c015a6c70c9028f47f2c18bb6cfb8d46d5e16c(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnInstance.VolumeProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ffbd0ef5f8b87f9c42c09b8038d3e08d70ac91ae4e60c9e24fd43b7a66e990f9(
    *,
    key: builtins.str,
    value: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f4a106aad6730f9ca5f686d6ef9aab93f20499e86fec16af163aef7ebf343991(
    *,
    device_name: builtins.str,
    ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.EbsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    no_device: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.NoDeviceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    virtual_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45379c3ed7954eb53d747ab4ead463612be3792fbeae21b5f509745cd20addea(
    *,
    core_count: typing.Optional[jsii.Number] = None,
    threads_per_core: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c7ae201613ad2718c445d39a0ac680b5d91a24d023530b4f9f672b6bbd84e99b(
    *,
    cpu_credits: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c09eac02d54a6564087da67099588cd163dab15cf7c17800691ac57e91afadc(
    *,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iops: typing.Optional[jsii.Number] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    volume_size: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2006caad7133f0ab7c61e8b156da32a8d1454211df92dd829182336ffa0ebb4f(
    *,
    type: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b0fb3dd7e11b3d77e5e684588da3e531072d536c01a1f2f8089cb89ffd0d393(
    *,
    type: builtins.str,
    count: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5c9ea6a0fe6571a95aa17f5c0b6f90e2695fa23c1a38965ff092c2938757847(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dae862a3b461d8dee633cb41e9b02aa56bd4ec0b297ae67d92791d54f8c77762(
    *,
    configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__330892e6831efeed9c5add9ac36c4eae4adff9e6648b88f0677f7d3f9047754c(
    *,
    ipv6_address: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aaee6a84463cd94666c3a6c5dc8639cb47853fcdf7ddc4f965316f0260f6985e(
    *,
    version: builtins.str,
    launch_template_id: typing.Optional[builtins.str] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d052358cb33e29932cee94076b50021e871c21fc3250e7670a7f774376eceeda(
    *,
    license_configuration_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34d8c3e0456d2764eb1c3d4b68e63d75d3e51811fe46a5cc1a3cd7a841079228(
    *,
    device_index: builtins.str,
    associate_carrier_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    description: typing.Optional[builtins.str] = None,
    group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.PrivateIpAddressSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    subnet_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5dfb67cedae0be1e7c4648da61cd29a55b6dc2ec2d3061d52059a4f784441ee9(
    *,
    enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    hostname_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f4ccfd0fce39abb37ef8133498166c476cc4ec24520f550b1ad8e4ff16a98de5(
    *,
    primary: typing.Union[builtins.bool, _IResolvable_da3f097b],
    private_ip_address: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3246e3302ff8df6b195439adc5ead244f95f45eca29b97351de498153f5e99c9(
    *,
    document_name: builtins.str,
    association_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.AssociationParameterProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b979ff4b2e7bc79429f0409f1fb60a5125a9cda71770a0324082ebc0a6c50756(
    *,
    device: builtins.str,
    volume_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5dd25848f0ceb23edd764d8f4a076cf8f9d22793b6ca99db922a9c410f58ba1f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    client_token: typing.Optional[builtins.str] = None,
    preserve_client_ip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5891536cec39a3051ee1e1e6cad74074ab2e104448cf33448a891defadf16b6e(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08af6017181d75f497ef7453c702f6e6ac3f87faf252f7dae4c9797af2382847(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18fe6754ba2f44060c4a7a2127a488b7e626c5c1761f524fdb756846a1b48e44(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a075309e51f465140660c0455acd101077c2364e286033707a8d1e11f4cc3a6a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a3c9af51a15924a206fae71c0b2615bf7be3e42b8bb7722c9e794e13a40973a7(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9a795e386e76f7e1445d90e3d1e800e540f41237f0e797a5e2058cb7b78553e(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3dd5921daaa37553fc9b30d074bd3ef6cfc6e9a796db9530140935d020cd87ae(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__78086551229af23659e2463ffd3801975d2b07247065af08d90eebf9e7f66ef8(
    *,
    subnet_id: builtins.str,
    client_token: typing.Optional[builtins.str] = None,
    preserve_client_ip: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__605ba8f22e222289aa0ed61b03690aaf9a4e8eabb86a9ba2b63d10f2bbee2305(
    *,
    additional_info: typing.Optional[builtins.str] = None,
    affinity: typing.Optional[builtins.str] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CpuOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.CreditSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticGpuSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.ElasticInferenceAcceleratorProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.EnclaveOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.HibernationOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    host_id: typing.Optional[builtins.str] = None,
    host_resource_group_arn: typing.Optional[builtins.str] = None,
    iam_instance_profile: typing.Optional[builtins.str] = None,
    image_id: typing.Optional[builtins.str] = None,
    instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[builtins.str] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    kernel_id: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    launch_template: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LaunchTemplateSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.LicenseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    monitoring: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.NetworkInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    placement_group_name: typing.Optional[builtins.str] = None,
    private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.PrivateDnsNameOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    propagate_tags_to_volume_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ramdisk_id: typing.Optional[builtins.str] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ssm_associations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.SsmAssociationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    subnet_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    tenancy: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[builtins.str] = None,
    volumes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnInstance.VolumeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa065a029e2c56d70c69099c85a03c8dbfa72480a3684dfdde80dc1f975d73d4(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed6eab34daf843734d508076e53ea4a173d898576d71d9ededed91159fb9ac83(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__691368ae493cae4bac13fdffb80ac19f0d8b2930d5eeb52667c840b0ffd8d536(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa52b53963fd1dabc3e917bdb98f2a4cedbad08b88a859b671f7f475926517ad(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87a0ecd2999ccef41b6baf7e5e653666a7205cdda8348b4e20f3b1babaf0ecdc(
    *,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1de6844e799c72712c1e89d9bf245ba313ed7d4d20f1567a28fb58baefc263bd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    key_name: builtins.str,
    key_format: typing.Optional[builtins.str] = None,
    key_type: typing.Optional[builtins.str] = None,
    public_key_material: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5cf6da08b13e85cb48d4ec206c808a58477bfb17a74904c2d65e719e3bc479ec(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__463ee579a97a03ee848867c464f5f6bcf3fe4eb6a58284e83950678f19bbdccb(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d3455748348646f19cfe248eb9eaf210442b42702c249cf6616acc5e68aad26(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ad171c997aa3530701089d85081102896744d5e3143730f0dc93d654a1915e0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cbcfd4d60002a30106d3b81cca62fc18c72ce126cc784c4428949c28c704aa5(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d9cf9951b85314af7c96e9bb1ba925d7301eb80fbd604b9a2fe74681764c4ca(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea1d23ec5083512b19c5063634a5083db2002e1d710831bd5081e17047b055a5(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3943c76f0fe4743ec822e1f5bcbc09e512b87b7e996b155bace897c7a248d65f(
    *,
    key_name: builtins.str,
    key_format: typing.Optional[builtins.str] = None,
    key_type: typing.Optional[builtins.str] = None,
    public_key_material: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9499e80b4296e1479809c7b5bc3f6e9f3d10776c827e6a75fe9385266896c29(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    launch_template_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateDataProperty, typing.Dict[builtins.str, typing.Any]]],
    launch_template_name: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    version_description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__64365a4d33f8b9644946798f4e453417c6eb4405260711ca681d0a287f7b888b(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52ef3ed9f5cbf3b14ad3dc73e435ae5e747acb3109599466e37bbcff4e27a7ad(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__befa19eedcb40ac18e92e5ebabdf929aed5ff042a077e649391f7928cde11c52(
    value: typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateDataProperty],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__759e1e9c4d73c033db7464dee63c4d038e63f222108109d50dadd53ebd12f3b9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__317523150461f66f07c47887b103a136f81671637f09dfe0f0c4ab6c2a4d0951(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49c5a4ace3815a530085bf4dde1426c80f7fae9aecdeacb884487520d363554f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4606ee5531c0c9932d485bfafc7e54fa72863e3924297890efdef03650e6ec3f(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__652e2c3e91267ba7d07bb5894d0dd532ec32eaf113bf034bb60d7e7682fbeb4e(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5438a142333f133eef7d17b761ec865c610e35c3898aaeced24d3a33681c704(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b11583349c048323414167490ce520ce6a2c88a94f22727256f4c8458131de17(
    *,
    device_name: typing.Optional[builtins.str] = None,
    ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.EbsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    no_device: typing.Optional[builtins.str] = None,
    virtual_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc6de33125d8db3c8e4de4a98d2195dad659080fa58344401764fbbcc0fbec96(
    *,
    capacity_reservation_preference: typing.Optional[builtins.str] = None,
    capacity_reservation_target: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.CapacityReservationTargetProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__353917311fc0ab9c3e0685812d142d513b65f96d6711992c0ac8bcd30e53a285(
    *,
    capacity_reservation_id: typing.Optional[builtins.str] = None,
    capacity_reservation_resource_group_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6398756f6434cab0d24e3dd07ede7ad71143f168865c6e672b04edb3a48ca849(
    *,
    tcp_established_timeout: typing.Optional[jsii.Number] = None,
    udp_stream_timeout: typing.Optional[jsii.Number] = None,
    udp_timeout: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92b7bc91aa2d524d3b92853936f95f64b742fff5188a86cd52b461fbf2d08da5(
    *,
    amd_sev_snp: typing.Optional[builtins.str] = None,
    core_count: typing.Optional[jsii.Number] = None,
    threads_per_core: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__650ea292c25895ae31516c706d23275a66f0cceb4abe283b392b67c0f180be7d(
    *,
    cpu_credits: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c8f1bdc026599f0d5c31661061b4f7adf3cd9a673d2d6a32326ec212ec24087(
    *,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iops: typing.Optional[jsii.Number] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    throughput: typing.Optional[jsii.Number] = None,
    volume_size: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19b96e3009604a8e3574248d8fbff3f4c10a28af70ffc935c66f594c8f18f6a4(
    *,
    type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1012f894773bff59813d4796c9ca396077aa7ac23f50a5a76d0e6942bb83b9fe(
    *,
    ena_srd_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ena_srd_udp_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.EnaSrdUdpSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa25bf3d4882f0042cd7fb73d4474087952f2b030a49cb6ce8d8ba8e7f927072(
    *,
    ena_srd_udp_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c36c5faceb0b39f4cd34426abd77f5b11c86067650f48eec6b4f48046bc4c53d(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__327a2a24a5b6f3f507a60eca3b04ff8b5d76348f61ee6cc88f38868c95e02406(
    *,
    configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6c21fc9ed54da66fa9f6700f883d379212a08d0a227c1dd67618d1265d105f78(
    *,
    arn: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__003d3ac8b5c132547bba40c1724b184411b92eac7e88c1091afeb7be99d1255a(
    *,
    market_type: typing.Optional[builtins.str] = None,
    spot_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.SpotOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5fc9ef3203af5508d5ac30f48557352d8fd1abcefdc9c04e40826c7c68b41520(
    *,
    accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.AcceleratorCountProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.AcceleratorTotalMemoryMiBProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    bare_metal: typing.Optional[builtins.str] = None,
    baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.BaselineEbsBandwidthMbpsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    burstable_performance: typing.Optional[builtins.str] = None,
    cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
    local_storage: typing.Optional[builtins.str] = None,
    local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    max_spot_price_as_percentage_of_optimal_on_demand_price: typing.Optional[jsii.Number] = None,
    memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.MemoryGiBPerVCpuProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.MemoryMiBProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.NetworkBandwidthGbpsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.NetworkInterfaceCountProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.TotalLocalStorageGBProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.VCpuCountProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3cfe8961eadb8bc57f35326a6ee53739d3a1d2f2f5a2330d9c6564f4ce7d1f71(
    *,
    ipv4_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__618292bbecfe7667a58541f030f774652abb4b04ec4cf699350c70493cb512e1(
    *,
    ipv6_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c01009dab469362d3432a6c66578fd0cc3f09d9c8cbadfb6bfef1866252c833(
    *,
    ipv6_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32e451f142fe00b3c107b71085c6014d26afe5f783aa89348cda122b9cc43ea9(
    *,
    block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    capacity_reservation_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.CapacityReservationSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    cpu_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.CpuOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    credit_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.CreditSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    disable_api_stop: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    disable_api_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    elastic_gpu_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.ElasticGpuSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    elastic_inference_accelerators: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateElasticInferenceAcceleratorProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    enclave_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.EnclaveOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    hibernation_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.HibernationOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    iam_instance_profile: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.IamInstanceProfileProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    image_id: typing.Optional[builtins.str] = None,
    instance_initiated_shutdown_behavior: typing.Optional[builtins.str] = None,
    instance_market_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.InstanceMarketOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.InstanceRequirementsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_type: typing.Optional[builtins.str] = None,
    kernel_id: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    license_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LicenseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    maintenance_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.MaintenanceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    metadata_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.MetadataOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    monitoring: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.MonitoringProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.NetworkInterfaceProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.PlacementProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    private_dns_name_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.PrivateDnsNameOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ram_disk_id: typing.Optional[builtins.str] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.TagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    user_data: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__335c8358d83d825d536f0cf63b36a23109d7286d681edac96c843bd6d30e6485(
    *,
    count: typing.Optional[jsii.Number] = None,
    type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea8bb22edecf7fdaa9bcd65bdd6872e8d86dce7ec73542de8ada65dfd42f6a16(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da6f057643821e4198778db605300559763cd1d337144d841e7dd3934ae323b5(
    *,
    license_configuration_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62e0d77a7fa9500aab5a08e932dc82213f11e05b31cf56f4654431c48342979e(
    *,
    auto_recovery: typing.Optional[builtins.str] = None,
    reboot_migration: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a61d16c29143184627c19c38cbfe78c2ad238ed306df35964b3c1b3daa551f0(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a944decb01c5cdfad894fed636b8467086175402c62f51700738f964ec9fee8(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53424c8c7e838584b59a51030b569a856ede8442605f1c59d4e589aa9b5a55aa(
    *,
    http_endpoint: typing.Optional[builtins.str] = None,
    http_protocol_ipv6: typing.Optional[builtins.str] = None,
    http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
    http_tokens: typing.Optional[builtins.str] = None,
    instance_metadata_tags: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18aa644a0bded5ce11cab52fe105e536d6c67cdb32ec43c901bef4004e8f0d1f(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9fedac138bd208bcab5a0d4ff7efbf5e7060acf961679f611e096cb15a8613f6(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__66fb50fedba927998c968d23061fff00f81c8ed406ead86c6cfb8a3628696169(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c599e12c3de63926f26bb5da3afad64e8c60b24c3b563faa2986e88c15da4421(
    *,
    associate_carrier_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.ConnectionTrackingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    description: typing.Optional[builtins.str] = None,
    device_index: typing.Optional[jsii.Number] = None,
    ena_srd_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.EnaSrdSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    interface_type: typing.Optional[builtins.str] = None,
    ipv4_prefix_count: typing.Optional[jsii.Number] = None,
    ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.Ipv4PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.Ipv6AddProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_prefix_count: typing.Optional[jsii.Number] = None,
    ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.Ipv6PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    network_card_index: typing.Optional[jsii.Number] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.PrivateIpAddProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    subnet_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab6cfd4307c62f4b0cd9a09bdc9e9e2583df0d1ddc9984a975653e43f89e243e(
    *,
    affinity: typing.Optional[builtins.str] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    group_id: typing.Optional[builtins.str] = None,
    group_name: typing.Optional[builtins.str] = None,
    host_id: typing.Optional[builtins.str] = None,
    host_resource_group_arn: typing.Optional[builtins.str] = None,
    partition_number: typing.Optional[jsii.Number] = None,
    spread_domain: typing.Optional[builtins.str] = None,
    tenancy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d69546b29bbd1f224f2ab9c89a842fc901bd4c6722d4900298ab916223412e2a(
    *,
    enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    hostname_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b6c5b5b228b065f6a57591206bbe516bb3639cfe4572dbb7cedd38475af51917(
    *,
    primary: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a634ae7e5758becae7a53d5843892730c9c079318bfa3bfc2e89825c3df5db7(
    *,
    block_duration_minutes: typing.Optional[jsii.Number] = None,
    instance_interruption_behavior: typing.Optional[builtins.str] = None,
    max_price: typing.Optional[builtins.str] = None,
    spot_instance_type: typing.Optional[builtins.str] = None,
    valid_until: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a8733748f9d5901efa1ec58843b400458e33517cd44b28e33bef4a5872fd248(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ed29fc8d7249edda98216958a9ce019c183fbac8bedcd813bed77b015d3cc0e(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__252291d10cb315c45deda9d788d7a3b1df2ea9f0c6cc6c419d2a245bcb858c80(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ec8b981d02ac258969e05ce7585fd8bc6c8a75db9044f873a95758a20fff70e(
    *,
    launch_template_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateDataProperty, typing.Dict[builtins.str, typing.Any]]],
    launch_template_name: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLaunchTemplate.LaunchTemplateTagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    version_description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72620c57e4f2bf7a9115eae14683be82615679dd719de82cc89cf920ca09c958(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    destination_cidr_block: builtins.str,
    local_gateway_route_table_id: builtins.str,
    local_gateway_virtual_interface_group_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ffe9c938b1e0b72a3aa305a264527da086b8a6bed3d2cb3286d8eabfdbe3f824(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec50537d152eff5a7daafd07e093cb27e49e3d0993280375144ce053cf2402a5(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__284f7bbdd38f7ad3348c9044b6b38e1a9461b65412f2de7bd853d0585652ad97(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__258fe4e66c64168f5e44e5f2492626784b284fa6f780e59ed909875e94b39e09(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58fa103093c5183e7f8dafe5b8c276c2282b2b68eb80103a08c264405ff5d125(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbdbb6e7afc1da4e3b78d537bfd48cd4ca542e7f284abad2c00f60672ea08b56(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__499c08d2030590469c3f75c2db0ccbf56b55e3c8147f40f2deae8d51f1e16ea8(
    *,
    destination_cidr_block: builtins.str,
    local_gateway_route_table_id: builtins.str,
    local_gateway_virtual_interface_group_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f9c82b014b2cf996c944f8ac77dfcd714445f9325eb729e49261180925b4fce(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    local_gateway_id: builtins.str,
    mode: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1d8e1134467f7e2d3e7c98d1c34ed6355acd715a1e19e8c325fcfe3629c6ddf4(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11527c45dd2e02ff7288c3b23407a02e25a092dc692463ba416672732323c71d(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8764135c1641b2203523cd33942af3fa2e31344ecb511bebe4ca29d5cae31d70(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e6d522d98a8fb40061031263e05658588786d15d85756c082a90c6ce0f56420(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__474f4bbd5ed57b4f72353a6d5ffc02e911411af536dcda10d9ff19641235d875(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b2df322e30dde560e72dd45e268c9483dfa622c0994e547c0799f7ab18ee4290(
    *,
    local_gateway_id: builtins.str,
    mode: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__942279fba690e3b98e5f34e81caaa9a7615238fc515203fa1334212075896e41(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    local_gateway_route_table_id: builtins.str,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e0090cdfca64ec4d1bbfb0e79bc4d70ac0e16c0b41e3d5a4f6379764eab22fd(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__795bf2d5ebe3651ebff429b9ef1073cafa616dacbc61ad7f7cad5996d170ad93(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f0258f30ef32e65ee0ff90cd3702b03aa634686401498bd56f0216eca60f0cef(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efc5db4ad316c716028acffc99962fb18c3565a9230f9c7a4ac17013a396d7f3(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8dc2642e9ef0df7fa52a5ba86e739132e5d4c9e28888baf78dfe07b4db11a6a0(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5c48f6b8e9634782c4f69b39340ebe9aa71051648046f1ad204ad1816bb18e6c(
    *,
    local_gateway_route_table_id: builtins.str,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50c4489e5740fab22081ddb54e3174bf9ad508e11ecbc13eefa82b53a4ebd282(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    local_gateway_route_table_id: builtins.str,
    local_gateway_virtual_interface_group_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d39418274eaeb02fc75ac2865586ff6b8ebd16a2cc61f6e8185359a87240a1f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a2e78d77a54b43dfe60da90fb91dfabd471092e95b875c27577371d55122d581(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00b8900032b020c8ecf3731ad9c656b7d99ff96247651f6db8828e7db8333ff7(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a41b6fdc992ef23b49578301926d25be90e610be1c62ae942896516610f7e461(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3480fc1fb89ce602f4bc2bf15c99da71be91c04a233e81dcafb2795f1355c034(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b9a8cd9288a52b6663080797430bf0981183639ee7ad7887a7ff932d017714e9(
    *,
    local_gateway_route_table_id: builtins.str,
    local_gateway_virtual_interface_group_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d23f1a46df0174ce142c0ff05ac9cb901ecac30141c8b466b44569b409414aa(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    allocation_id: typing.Optional[builtins.str] = None,
    connectivity_type: typing.Optional[builtins.str] = None,
    max_drain_duration_seconds: typing.Optional[jsii.Number] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    secondary_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    secondary_private_ip_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdb247dbf854f85e48e3d293459592f7c17817fd538cc790bbc2b953d197c893(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ccb9afd936b7ea3bdc26e449176215293a7150d149aecacc164a3b752bff21c8(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ea5b3187b853cfa340b72b2a61dc1a1d7320459e754c328fc7013f403d31c74(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4cfe702c80e90b7e94df290ccbd9b1126a59f7167ee8d0b08ead001f4b760be(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__876ad6282ee6cb51d07bc9ad188a0cd1b3e56f76eeb223668608b35ad422b23a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d27a75587aef8f41874e3425910acc61091eb1d6163f756677bc9a4cf75abb5(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6537dd3590fc4a352eb713faffc379d97706a253c00d5712e19a55f55b2e0f35(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f9000fd8f77350e1a52d17cbdb7cc11f37c348d2f5717255745539ee5d28f56(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f19a6be27e712f51611c6896aa7f080c172150b391298495387ab2307eecd23(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f95c2f3e513b379e30162aef0ef12684ffddc3d711e6a83303fbb920f2f3487(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76a6a3daaab575df04de03efcf802de9ee1357d57a0474a96922bc7d42b638e2(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1aba83edf7a8e3f14e1d4f9ca76c7049f7f7c569d2ffb43bcad65b330ee9a581(
    *,
    subnet_id: builtins.str,
    allocation_id: typing.Optional[builtins.str] = None,
    connectivity_type: typing.Optional[builtins.str] = None,
    max_drain_duration_seconds: typing.Optional[jsii.Number] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    secondary_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    secondary_private_ip_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__63ab91eb0620cbae6ae1a944345b6c561c70134e58fe810193ad3be248faf08e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fe39a240a6d0a1f329485e9ae7a28d0cd7945ff27d2505d051744187043eb6d1(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__66ec96ce0ad1840d07255ec22b8f5655663f6004c4dadfe16518083ec35f8ec1(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__601d1eecd1d541ed4359648f8987e7f0c1586ee8c30a428d2784f12903f027b9(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57b49669fc82f61a0619b6f81ea70040da2911bd088956733571d0ccefef92a3(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19a17fef3fa11c116781af713a02917ffb22907292ed07e600fbabfb34ff85aa(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_acl_id: builtins.str,
    protocol: jsii.Number,
    rule_action: builtins.str,
    rule_number: jsii.Number,
    cidr_block: typing.Optional[builtins.str] = None,
    egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    icmp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.IcmpProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f78b787a243fda4583b640a047854d253c8571e9d307cc5ceafe477c1745b178(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb01dc92902461a71fc556995b03455fed5965d2b1548f2381bc82b583b4bcb8(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5588a9e32b91ce07908bc6161c70a3321011b4a40f6187709a1b19411233a82a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86505e85738323ea818a1610435eace033b1dd92450cde0e2051dddc6e425d81(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4c19a5c3c4f835d900da5c3a7da29b7dae9ed72ede397df02aa3b5e5dbc7c2c(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__254c3e7afcaa640549a034dcc005709b57dcf456e261c0a220d284c9390f74c0(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__129ecbd2fa74c873db5d2e4445a6d4ee5848a7ae54ad620420c16424ba00add1(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08c5f0306e44ef2382acc0166275e531bf85b83c5858166b4228bbff43cc19fc(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b053e8a1e1be8a080aa0335f9873632417b0a52584e06b761a7084959c966bc(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.IcmpProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__04e2aeb5634b173e21270f0907cd73e640f758e6e692039079590ffd3d306ba0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d484cd32312fbba1da3eaef2ee23a41c2d099c402828e3b5a4713187568098d(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkAclEntry.PortRangeProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0db35b941edee121dbe70aad21d789ad482729a830de6371c64bd02f1440dc0(
    *,
    code: typing.Optional[jsii.Number] = None,
    type: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__afc777693f9aa0b09a2626bc7d7fe62ad0760ffb7468f177d913ba053b48cf13(
    *,
    from_: typing.Optional[jsii.Number] = None,
    to: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3acf503d4b182329e1fcd58e01c111f3c896325c25e0cab3daa1d1107293e25f(
    *,
    network_acl_id: builtins.str,
    protocol: jsii.Number,
    rule_action: builtins.str,
    rule_number: jsii.Number,
    cidr_block: typing.Optional[builtins.str] = None,
    egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    icmp: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.IcmpProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkAclEntry.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__15f21d92eb458fa0909676d3a26ee9828dde8826809c48354215e1a66776d40f(
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__09b42a4fb4e9f46bed23ddfbf1c07b2a0ba5e4fce3bed5ffdc5d40d39c2f8ffd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    exclude_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    match_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f82b6edd1eb1b26cfbde99da725d72fca487a4954f8210236670099b07e4389(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b30482d779ea4915ee6674a7a8f8c7418883ca6e720b6b11926119a171f06434(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6bb0347180a5ec3db3a346f37de5fab9530bfa7f80f40f6b23c6d2bdf0525f22(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__65876aff79dd4703d35911a15193603293801dc94a026bc18667715be0714b74(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a0d4ed7f5b5d6568c9fb7c0d99b3085a29b3ecf85d1e42a3766dca2e9e60034(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6479b3ab49757210a848311fe5bc0762e4e69165883629ed0f5af1f54e1c437e(
    *,
    destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.PathStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.PathStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    through_resources: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.ThroughResourcesStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ee0103585d5d78120d38ea844a62f80bdab984d8dd6f86aa16b343aedc1c6fc(
    *,
    destination_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    destination_ports: typing.Optional[typing.Sequence[builtins.str]] = None,
    destination_prefix_lists: typing.Optional[typing.Sequence[builtins.str]] = None,
    protocols: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_ports: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_prefix_lists: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93939c954b7527e924a6bb467ac28976dae5a92c7d9d73a22cc548e3af25e1d6(
    *,
    packet_header_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.PacketHeaderStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    resource_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d8211512ba3ac4899e7d8c3bf7b860e597fb5de548139d64df2067625abcaec(
    *,
    resources: typing.Optional[typing.Sequence[builtins.str]] = None,
    resource_types: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25edd4e745cb3b2bfba6b70745820805974b1ae2ef9d490e7b232b0b8a720b6b(
    *,
    resource_statement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.ResourceStatementRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3a18949cfdbc5dfd56eecde43f3705bb58594f84d85b5e275c607e6230ac9be1(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_insights_access_scope_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68cf59f8d4cf1c47ec6143ca5ae0d86c2d23eda017b95478e02794d1802115fb(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__be469dd814ca765ec96bb5f8ddc18f7a35d96d393de5ca5220551968e50e4a46(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2e6193e07361f6833215e82224bd3bd89dd2f89ac49cfcf28b160f2b6bf214e5(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b40caa93e4cba14aa0ed92e1157e230d9574ded15319d47645dac942e2a4904(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6456971e54f3d6847be0673f8e983c36e0c8fa5cac3cab9cd3eebc9d3fe829ad(
    *,
    network_insights_access_scope_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__97bfb3f2e7cd49d7181b48521f8fb397e6d46ad8504bb9c725209cb75789f6db(
    *,
    exclude_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    match_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAccessScope.AccessScopePathRequestProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__678aad296e8f8e492a0d5ebb106e185ee0e54a22ad01e148f0ae03d0090508d2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_insights_path_id: builtins.str,
    additional_accounts: typing.Optional[typing.Sequence[builtins.str]] = None,
    filter_in_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__511339e103b3d28b7af09ce19b36ce54bde77d57587d4e29f2c94e9283956101(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c131de58a1c5605791fee50271e3a5ca23af6236ecce8ebe988aca3273e8817(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83f5f2cf16339baf897c63be3cf60b3efd0d6b4e660e79516e522a217a0832c9(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2df3bab5870c8ebb5ce0c70ae7fffe3391dc7b093a2f7778407d2d629f1343f8(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5fc330fa3d4b736d5224dcb5d8f30fe938109a4316d70b31bac388cd1a1249ca(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9412010e2d8bad87553154226eb22ca797b6afeb1de0474359133f2783db6f65(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fedc66c800cdce70eae824210869d84cd51332bedb7734ee970f48424dbb743(
    *,
    additional_detail_type: typing.Optional[builtins.str] = None,
    component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__beadac39f70cfb599aae93e9b749826b009e53c821ac630de967601f6c75d771(
    *,
    component_arn: typing.Optional[builtins.str] = None,
    component_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8aa10b86404f3998dbe1360ff1debd11265210eb283e280175517a104dc74916(
    *,
    cidr: typing.Optional[builtins.str] = None,
    egress: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    protocol: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[builtins.str] = None,
    rule_number: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4ac71e6be6b0897ab2eb9eb5eca0038909daf307ba2e83852fdd87c048dde08(
    *,
    arn: typing.Optional[builtins.str] = None,
    id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__55653e2ecd12adb9d8fbe5221699b12bb7a99170d02ae297f5101be79a71c33f(
    *,
    instance_port: typing.Optional[jsii.Number] = None,
    load_balancer_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__588df4fe383db28c254ac1e0b5038bf76c6595169cb8e1793603b7484a91f5f7(
    *,
    address: typing.Optional[builtins.str] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    instance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1b9ed4cfdca71ae812afc237ce3637efdb06e9941b733aecb5d14b8c23e13e4(
    *,
    destination_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    destination_port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    protocol: typing.Optional[builtins.str] = None,
    source_addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    source_port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1cab8f6f2694c19d64d18c42adfc7bcadf44aac28e3615ab8e4fb346560ae36d(
    *,
    destination_cidr: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
    gateway_id: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    nat_gateway_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    origin: typing.Optional[builtins.str] = None,
    state: typing.Optional[builtins.str] = None,
    transit_gateway_id: typing.Optional[builtins.str] = None,
    vpc_peering_connection_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eadc9a243462ce71c1e75b40c5188e1a6f0628d56b7ea73d3419ae8d6aafed6a(
    *,
    cidr: typing.Optional[builtins.str] = None,
    direction: typing.Optional[builtins.str] = None,
    port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    prefix_list_id: typing.Optional[builtins.str] = None,
    protocol: typing.Optional[builtins.str] = None,
    security_group_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed8878c4db91bf6a50590fb78c80ba9f44606a81d0075bc1b9a4b4f11d789ef9(
    *,
    acl: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    acl_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    address: typing.Optional[builtins.str] = None,
    addresses: typing.Optional[typing.Sequence[builtins.str]] = None,
    attached_to: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
    cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
    classic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisLoadBalancerListenerProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    component_account: typing.Optional[builtins.str] = None,
    component_region: typing.Optional[builtins.str] = None,
    customer_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    destination_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    direction: typing.Optional[builtins.str] = None,
    elastic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    explanation_code: typing.Optional[builtins.str] = None,
    ingress_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    internet_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    load_balancer_arn: typing.Optional[builtins.str] = None,
    load_balancer_listener_port: typing.Optional[jsii.Number] = None,
    load_balancer_target: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisLoadBalancerTargetProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    load_balancer_target_group: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    load_balancer_target_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    load_balancer_target_port: typing.Optional[jsii.Number] = None,
    missing_component: typing.Optional[builtins.str] = None,
    nat_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    packet_field: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
    port_ranges: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    prefix_list: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    protocols: typing.Optional[typing.Sequence[builtins.str]] = None,
    route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    security_group: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    security_group_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    security_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    source_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    state: typing.Optional[builtins.str] = None,
    subnet: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    subnet_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_attachment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_route_table: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_endpoint: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_peering_connection: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpn_connection: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpn_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8aba4747fa922bc0165e7923b126d79994a2328fbccffe6312921668d032818c(
    *,
    acl_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisAclRuleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    additional_details: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AdditionalDetailProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    component: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    destination_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    elastic_load_balancer_listener: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    explanations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.ExplanationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    inbound_header: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    outbound_header: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisPacketHeaderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisRouteTableRouteProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    security_group_rule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisSecurityGroupRuleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    sequence_number: typing.Optional[jsii.Number] = None,
    service_name: typing.Optional[builtins.str] = None,
    source_vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    subnet: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_route_table_route: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.TransitGatewayRouteTableRouteProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsAnalysis.AnalysisComponentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__409f0466dcd116c1df92bba15329f6279a2e75d43d1f6456cb6b8d6f50f224c4(
    *,
    from_: typing.Optional[jsii.Number] = None,
    to: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00d7e3a8e802c3ad59e6e5714eeb743641381b65101c240af6b9f93341e5464f(
    *,
    attachment_id: typing.Optional[builtins.str] = None,
    destination_cidr: typing.Optional[builtins.str] = None,
    prefix_list_id: typing.Optional[builtins.str] = None,
    resource_id: typing.Optional[builtins.str] = None,
    resource_type: typing.Optional[builtins.str] = None,
    route_origin: typing.Optional[builtins.str] = None,
    state: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a33d492e092024ce4f03ae533f82763ceee950f76808ddc3b6329ed54b1a7731(
    *,
    network_insights_path_id: builtins.str,
    additional_accounts: typing.Optional[typing.Sequence[builtins.str]] = None,
    filter_in_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7fe7e248a834a6efe9954bca662d634bc784a1945ef06a82f8e180a1b786569(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    protocol: builtins.str,
    source: builtins.str,
    destination: typing.Optional[builtins.str] = None,
    destination_ip: typing.Optional[builtins.str] = None,
    destination_port: typing.Optional[jsii.Number] = None,
    filter_at_destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    filter_at_source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source_ip: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__727c2e90bd02c8a49ccd06e5693994d060b2fb6dd8d39545ee9042b07e48c943(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cccc4e27f3a85bf70ba5c68ae3e76300babfd87cf4de27582cdeae7be744e0c(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1a79262a8e5afad332c30acb77a35cb1268b2ae8173926fec6c86d65d45a8ef(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a689147656a18301a3ae4415c5486f925e8fda67c8bab29c04b90161386bb930(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__df96fe03f2b38a35b14ce16c9edf72487a38c9e53522a2844abae3f05d05a74d(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf89bbca436bc848953f41e635653aa1d55915d7e8fd29c6e7e2674bc683c7b2(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__273be4117afb24e4f9c1919e2eb7009d1427f7300ea7e3e4aabd339109710388(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7de97fb08b3979783843344622441f0aba608fb5bdd1d75d9d83dea45b1138b(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29bb049b177504b26d9314549066eab8e02aa2539e21e83ddc4cddaafbeddc76(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInsightsPath.PathFilterProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25b7233d52c3940a670ba0d354408632b91d33abdea67df95c45adfd38a19ed7(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e631c64467884caee4a0ceb81a0fe348d1dbe4d4fbd6fdbcbf507bcd3be96e1e(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5b6b14caf6e6967872e22c2813155f115beea081480b6a0e59aa8805ea09ba72(
    *,
    from_port: typing.Optional[jsii.Number] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__faad4550eaf1b07ce0dee675d9dc5aaffde167e22cc470d3f29dd8c2e4b4b3be(
    *,
    destination_address: typing.Optional[builtins.str] = None,
    destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.FilterPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source_address: typing.Optional[builtins.str] = None,
    source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.FilterPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f101d0a990ddf3dab968e411a0437d6e2154bb00c3ff7ef35d0afa814c09c74a(
    *,
    protocol: builtins.str,
    source: builtins.str,
    destination: typing.Optional[builtins.str] = None,
    destination_ip: typing.Optional[builtins.str] = None,
    destination_port: typing.Optional[jsii.Number] = None,
    filter_at_destination: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    filter_at_source: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInsightsPath.PathFilterProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    source_ip: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8393da3cca9727d94c340192bc7d8b11bde1fb62e8d43771091b9a3e120a301a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.ConnectionTrackingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    enable_primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
    interface_type: typing.Optional[builtins.str] = None,
    ipv4_prefix_count: typing.Optional[jsii.Number] = None,
    ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv4PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_prefix_count: typing.Optional[jsii.Number] = None,
    ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv6PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.PrivateIpAddressSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36528adc5439ee87edbb54d96f163e3f07cf28679f7d2c3a64683cc2f634c13d(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3c1cd8b47c372cc1a6fe2ad744be04181d2deb2f86b9056ec1dc305c8f30bde(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d46166d55def79a5e6b84dab29e5f6750535d12b7cd3dd8f7b7fbca8177d2bd(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__326e9b0264afc77aa0c36f83fe4fc0c5c45684eb1bef0b84c090fe6a73606fd8(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.ConnectionTrackingSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b42a1901ff08c6187aea659b7ab30af39da037df52862dd2fb4661cff86a650a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b856c33b68d0ad4d8f64d7064b6551f3a20f184bd0bde1d2697f8f87ff0f02cc(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__33961d8033f73df9d276a5f4d152a5e51803192bd216c4c1de476cdb04ef1165(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__06ca573668106730ff2f3a78bb55507676f54e57996a31ccaea4840dac9f4452(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e371f5bed19ead07cff146cd07611a39380c23e9712dfd72904565ca8f9a7bb0(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd643933b52f02097d39ab45f65c2e07f4f6e1a74aa7d9d10ddda902b793faec(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv4PrefixSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e27163d6b64f17a9cee7c8cd34a6efb53a01d0f3826e972e894c6f8d6146d3a2(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec2f431d0253f1425093379bbed39269acef6002d9a6a6937578e7542e26a30b(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.InstanceIpv6AddressProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__afcdb033156daa389c5aec6a9129fc785ec6caca4c5d07dd806d875e836cf591(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36c065ce0b45ef97c2ba76327e28b0a2f20d775d10bf7f29368ae2928519a859(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.Ipv6PrefixSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12f6d832e68daf5d32cdaf3fbef11f9b066f61e755598181f9d4e11cf1142216(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9abc518674008194abac9a771b948d64ee80e214cb425ae037f288639dc89da5(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnNetworkInterface.PrivateIpAddressSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1425a70b1facffb8491c8d7d3f99bb7924e01c01241fb60d1c11c2772ff715b9(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f221feb4b623eefef062abdc5ace0a54c176344126862c4806c435da7f3a4697(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdd53da68121c116130e4262ff68795dc8631f701d848bd6519c93813c05583b(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__37da425035e16a13c422186f0f8aed1970a49f480858e8ee93f7ad6e18e563c4(
    *,
    tcp_established_timeout: typing.Optional[jsii.Number] = None,
    udp_stream_timeout: typing.Optional[jsii.Number] = None,
    udp_timeout: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52bfc9d4c4cc10dfcfa5ca2b158de5da7d500b8cdd062f141f3a855f70a6e1f0(
    *,
    ipv6_address: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38380f5705d10d112c9c88463594b275fd3742077a27edd72850daee8c83b3d3(
    *,
    ipv4_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd87b859450e8afeee0ab152a487983d6896c50bbdc2238c51903c507f7e6fcd(
    *,
    ipv6_prefix: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2da2a4621e14b60dbae723cd0270f439aa232756c238ce733bfdc043ab3defd(
    *,
    primary: typing.Union[builtins.bool, _IResolvable_da3f097b],
    private_ip_address: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3bd398f8321bdc7fbfd14c84bf37b253e1282ce256683087217df8bdb9917aa6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    device_index: builtins.str,
    instance_id: builtins.str,
    network_interface_id: builtins.str,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__554cd7341909721afe1ab2997e383a1d6a07869eba1d1d0fc42e2066bb43895d(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02eddcddc4e9a3e34cc764cc9ae14a1b05b7402c6a41e0c8b4527af6823d5fad(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cad57983c8bfca5f6e07a872722208c9bc1ba7507816b15b90198d0009a51999(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d163bbe0d4a2b99d7ea2fdc44ad45b5c52fb1b4af5eb21863c6448d14ea0555e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46699c25e875aa0da863603cb428ced738d417364fcb7a74753571a623b15164(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__95d995f5a17b7339e1633a46f4caf7b0334f3203bea60f5970be9e2f2a14077e(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b31ba98e2404b0fe712cc8951c65f1f317583a51d160007f9b90f285bb851816(
    *,
    device_index: builtins.str,
    instance_id: builtins.str,
    network_interface_id: builtins.str,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d04040d32749eaf3985c1db0ca5e7ab89686b04c123ac655d10a79d911798b72(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    aws_account_id: builtins.str,
    network_interface_id: builtins.str,
    permission: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6630593b6906e3e825645aa005b07fca83ded6bb20f59be204dd64d71cbef75f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a83f7be39b8ad366d5db2d2997e2890a011005f755783a103835e1ad3f3bfe82(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f32b4b2dd695db2a3e55851e1666aa9581c8e0034cf76de07a65b5ae3a540528(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18507370afff5c5b540a79b3bb07ec48f9bed4f562f3c9166a720678592744d4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d12aa916b509342365796d7033c079bf6fe03d9bab12c347d2e743a6df67f051(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__44e9326bdefcac87e9402f135aca64141cba9da3e221083d335c9f71322de46e(
    *,
    aws_account_id: builtins.str,
    network_interface_id: builtins.str,
    permission: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__419471c10f0cbd167ba77e8ca653474603529157eecae56a55b928c65c5bd8da(
    *,
    subnet_id: builtins.str,
    connection_tracking_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.ConnectionTrackingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    description: typing.Optional[builtins.str] = None,
    enable_primary_ipv6: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    group_set: typing.Optional[typing.Sequence[builtins.str]] = None,
    interface_type: typing.Optional[builtins.str] = None,
    ipv4_prefix_count: typing.Optional[jsii.Number] = None,
    ipv4_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv4PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ipv6_prefix_count: typing.Optional[jsii.Number] = None,
    ipv6_prefixes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.Ipv6PrefixSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnNetworkInterface.PrivateIpAddressSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    source_dest_check: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8d839a4732c7183d1bfd72bdde3e65a5d7171baaefb0d8668061036128bf7fa(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    destination: builtins.str,
    metric: builtins.str,
    source: builtins.str,
    statistic: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__527207c99eaebbb38efad5ba00945aa9cd9eb1944200862f44c3d4afc1fcc6e2(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cda4b0050e40ea9e827d36cb99a0e658ced602a74e11763bc9ae83fb41a6e441(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aaa8f700005093a547dd057bef2ccb53e454f65307b085a9586f53f613954081(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d8013b3d594ef7e504666911164ceee162d4b7a9d7a6b3f9cd177c2d1c92d95(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7654c501c13366d2d7aabc76cc664028bc5f49222a9e4bbe79ee8952952d62d4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53342e79b1ba040609233c61600360c4528545cb0bde8de79f6cc245e23cadbe(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bd09b09944dd4da15b677a573d3eca3088dfd3191645c1594e6da952c55a22f5(
    *,
    destination: builtins.str,
    metric: builtins.str,
    source: builtins.str,
    statistic: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a97e959453a7a8bdf073b17dd25f0fef03b744fe7cdb8e70900df3652bf8135(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    partition_count: typing.Optional[jsii.Number] = None,
    spread_level: typing.Optional[builtins.str] = None,
    strategy: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__085b1a77e66c9da88ad57950d4d13acddc33a0de5d747c359b19fc24f824eb83(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__60da1d74428021588b55a1b634d5e30603fd325314c71332bdd1673b924b8434(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__deeb2339c374b6f3d71d70e14c8ba3cb0726eaf3538217fbfbbf0beff83d87f1(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__019f535122ab6bb315651486be64d12d84c71f880b4a4e736d246b32953e0a7c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58e6e68236c872d0e598f52a9948df6a54331b3506e5babf75a8de8e6327e9cc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2a1ad80d3bb914b32525316054ff14b0ce299340d3090a1f9dce90cd3c50c0a(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b7c1be4a84fce81f03bee89e965cb0205e9fc7599fb2de40c2bdb49aee8a1ca7(
    *,
    partition_count: typing.Optional[jsii.Number] = None,
    spread_level: typing.Optional[builtins.str] = None,
    strategy: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca40c21d744d74a8d12faa4a15d3401bfb9dfbec7caccc06e6b5e838a4539f19(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    address_family: builtins.str,
    max_entries: jsii.Number,
    prefix_list_name: builtins.str,
    entries: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62322c706c8ccb56f4c1c382d594a4dd172bfc2026bcfaf8b6d57a0c1012f977(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a51658df7b5e126e6d4fc38aff0b123c13ff470cc34c2fd33c0b45b9d4f7297(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__543e8dfefad13c341bd9c21b253b583e2dfc0a1d6ec147009533000ad36a22f9(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ed7254f10519f5d8ac376f56a0f44399f3d7551f32d71c5509ea1ccd7c2a3cd(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b27e5253beae7ef8a4554ded2f450182a10af89fc784f4ddc89aae6fc1df8dd(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__020c41fe6785b20283e5bef3edd50f44004ef8ff7348a874b2dc0f408c75985f(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnPrefixList.EntryProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__712ae4f3a545a01afff1ee8200ddcf83e24e0045c90518644081a2620e86972b(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__836b191de61cf7c801ffbe6a52116262c188564ff3b6f7de40d432b6a80ba5b3(
    *,
    cidr: builtins.str,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ee3ea534076530da265ec0754410eb853bf7da980bbeaabb96d7fe30a9204813(
    *,
    address_family: builtins.str,
    max_entries: jsii.Number,
    prefix_list_name: builtins.str,
    entries: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__418aadfc2c6984f0ac75cd67e36ca76f23d9cf7bc23846cf55d7b3cdbd691797(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    route_table_id: builtins.str,
    carrier_gateway_id: typing.Optional[builtins.str] = None,
    core_network_arn: typing.Optional[builtins.str] = None,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
    gateway_id: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    local_gateway_id: typing.Optional[builtins.str] = None,
    nat_gateway_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    transit_gateway_id: typing.Optional[builtins.str] = None,
    vpc_endpoint_id: typing.Optional[builtins.str] = None,
    vpc_peering_connection_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6be65f2a156289dba30c6b64726cb3622e229f7b1e4e152487bbd9e0ecfb9d7d(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a9bb73be2078411a9f0d4740a463a6f77c635fe220f5351d3fc9e0f442d2061(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f8db87996585873368487fc20df4ef16915a47f32a4459b4643d211faf6b65dc(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__355c5c80f08453332882507836cf0441e37ed4a5c9fa46ef1c415dd739491b7e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__535edefe9ec250f819eacd60779bcf6b8d4afa9cd9b9ec8142ddfb03034be5ac(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ae05f819fd9822a84fcac1033a9bd983835b0e75eb0d432aa89d5973585cc3e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9053d56266f2ecaa5d8209e05a5af048fd6c8540eece0de592fa617598e87e30(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28b2d9e818763b23c1689ff8d32ac779a6cdf2e20e4e1b57f65f0f3474ae8878(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d8f8dcc844a05743d981c217d51303c0c4cc6e46dadd5339a6eb261fe327b128(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c49944ede227d758c602f9702b54e035d5067af2a0424d3b194ba7311c44aea8(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d987c0fc0a014587365521959275a5a66f3fb9212aa1ef3e47b13ec24a3291a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46d262dfaa3881555d65a46e9b26bc3ad572270d792880fa9867825c43d6b51c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a847890b57b0439222d2d701c672a84c0722c931f9b262edafa5fed2a6e2f84b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__266f068b50cc854a81450a8d5e3e82022666389ba782b94a359557a139812aef(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82c38d5de8dba90584bc4953ed11041cd571a5742b7358ca8dbaa9d4ce4aa9bd(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b3588c8e5a495d9ab8a2699ed72f7253e15605bba594e43b65e5892bcbf1ca0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46892d5dd1581aee0dcf6410687f88cfaffdfdd18c726880534edc8f86e9919a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f90e7814d59b7c562ab4b24d54461eba6a4c88fbd5451ba2b2b0adf8441a452e(
    *,
    route_table_id: builtins.str,
    carrier_gateway_id: typing.Optional[builtins.str] = None,
    core_network_arn: typing.Optional[builtins.str] = None,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    egress_only_internet_gateway_id: typing.Optional[builtins.str] = None,
    gateway_id: typing.Optional[builtins.str] = None,
    instance_id: typing.Optional[builtins.str] = None,
    local_gateway_id: typing.Optional[builtins.str] = None,
    nat_gateway_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    transit_gateway_id: typing.Optional[builtins.str] = None,
    vpc_endpoint_id: typing.Optional[builtins.str] = None,
    vpc_peering_connection_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93a1e7c740b947cc510161b87d4afa4b057e501067ea1f7ef24fdb6a8ab5614c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cff9836624fcf3040188660643f84ea5ed967e0aefb5879689106d7a284610f8(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__210d22ba03739538d1e761f7e067657a2a7df6962e5beadc43dbfbaf9959ba5d(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7817c70f941079d8bd72522227f92459adefb6aa05d21e93a59b57d500b7fa4f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1f72e62e1c77480bfaac479cdae53d464d07797246a34e3cc9551335c3da767(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ed47752a654feace43cbbb783b95bbd42507e651168521e8b12b49c07d72609(
    *,
    vpc_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d683e3d98ba1cf2002a34b5f2c1fd4a4321e62dc852c644de658a8cac860b36(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    group_description: builtins.str,
    group_name: typing.Optional[builtins.str] = None,
    security_group_egress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.EgressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    security_group_ingress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.IngressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__946b476b6f9040093c97a64d3216b8b663100aa6248e967683a518f613c6650d(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a9218d8e00e7a6968dfa94cde1763f41e4b171ef6f953ebe5b263feb896fce9(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__17ccc6763068e002855069b1934ac3408a3db7f3bb73ce74a6e7a0eceb80cbb1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__735e91dbf5286e6f0c6a7dc175aed5716375fba630ee09473401e3cb4c27990d(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e697e16c1dc9b050f938d76c69dd4315144185a4d193fc14e6411676b9f0add2(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.EgressProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__657a86e3aa98e6280b9cf9b7e38fcffcdaa2731104733314d42378aaa68c3fdd(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnSecurityGroup.IngressProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__320649c55eced315e2f22059c7d31c15f5ec1871be4f9915f220a08b74772226(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61d4413792ac35911ce993c205d95f44fc3caa0ffb0d0cc412772dfe65fd7dd3(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f7f9c3e8bd9fe395c2fb15fd9d38e6ef1ebca888c954597574840d2026080b54(
    *,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    destination_security_group_id: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c5b613c6071e52a9a418d9a5233b95303a864edfa1054ce34648a49a7c6a39b(
    *,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    source_prefix_list_id: typing.Optional[builtins.str] = None,
    source_security_group_id: typing.Optional[builtins.str] = None,
    source_security_group_name: typing.Optional[builtins.str] = None,
    source_security_group_owner_id: typing.Optional[builtins.str] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c15a8a6cb1de72d8389f735b2b19fdd74abd3660cdd4ae643b096e83ad96f15d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    group_id: builtins.str,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    destination_security_group_id: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0710ec20f8067c2d668b2e2bdfa5122af55b09124e593a4a92edb1e4492b196(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__17caff347875838ac5036aa298e542710f531c84f731ed8356dafacc9b178213(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6dd026961f5d12b1303998367f7c3b149ef05ede270fe566f64642ead49bf298(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08eae465a8bf866a3aaa79efc2f702fe807f4afa34cb02269c0c58b015f1a294(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b69875fda44676a82ce37788aad70defb56617b0c1d6d63d8e080525dbe08906(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b156e438fb00a55c71c70d77360979375bb3c148566f31dd380ba7fdba0da96e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__078894fefea681a837f5bca96689a387e5d72cd4b49a6f4d9bad3dd092a7535c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d794e565aa4cc41d252dd3c053188ac46b954545c0941f9045fd7d6df3e37c80(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a67fb1b21738daa80841f7c9adc5714d151c35110346e73a66f1ecc9040089a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5af4fd65ecd7e49e99f253851ed8fba2f9dc8426e8b1c0dbfea72697d038f986(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fa4cf3aa336f687505ca75fa71c749bbde6e65bdf3c04bf4137674763b9cd71f(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d33f1a1fd42aeda5693443b41a05760d7d754588b339339e6af41df9f15afb04(
    *,
    group_id: builtins.str,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    destination_prefix_list_id: typing.Optional[builtins.str] = None,
    destination_security_group_id: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__99cf71ba90fdd23ce4fa6a965bf9e8cb57a3209fe7de8914f15c94b67e357708(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    group_id: typing.Optional[builtins.str] = None,
    group_name: typing.Optional[builtins.str] = None,
    source_prefix_list_id: typing.Optional[builtins.str] = None,
    source_security_group_id: typing.Optional[builtins.str] = None,
    source_security_group_name: typing.Optional[builtins.str] = None,
    source_security_group_owner_id: typing.Optional[builtins.str] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51183013e439efce6ac8bedbc4bfb686a5d94f9530b28cf72a834b681ff6a6b0(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__26028434fdb84281d551c700d34142ca5185c12eb87fc76d4e22d061aee3a441(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0fb423251dd58c8eba6fd66411dd947a25c70ae1162c5d8f4d45e7df38b09670(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85ee28d6bc44c94e0cd7644a5ef96652bbef3b8bc5f79067580a31cdc44922ae(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__752a27a824e6a4b39f735f987c2e8812ffe675605408a151aa5aefe7b2a4c698(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e23627da1e141f44c0850f243dc525319bd08080d3c5a976ba721e6b0aa9a6bb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39e16b8ebb7d71b585aa6910df1a93f1dc36d419ee3bdc5f8f5d1e8cf8b18014(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__338c8ff9c804245c7a3e32a4540ff5a8252c81b08d80182f0b2de5d40434c69a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c75160a31adb01e7ec3b8f1d1d263e2fd14e716f202cb36412d72885e45a74b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c110b093f13dc2ce5d12b8b8f73d53b092cd966ae2de4f5bd5054e6824056269(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2472cce371b656bb65ca0993578ff7a45d796afb07a89e30393a2975942cc331(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9c4395f9fe936ca2f0ef917f77b0c90bab4b67f95e5808c4214967d4301ef8aa(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2cf91ed7b67973212326d76bc04e1b4c178b69d92329ab670078072e27757cd(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14c1913a7e3440114741b0331b2106db513750734db62f32370f04806f56e1b5(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9577309b12889b3c94a45de262d0695890476aaeb9f9797887f45c0f9c6a59ca(
    *,
    ip_protocol: builtins.str,
    cidr_ip: typing.Optional[builtins.str] = None,
    cidr_ipv6: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    from_port: typing.Optional[jsii.Number] = None,
    group_id: typing.Optional[builtins.str] = None,
    group_name: typing.Optional[builtins.str] = None,
    source_prefix_list_id: typing.Optional[builtins.str] = None,
    source_security_group_id: typing.Optional[builtins.str] = None,
    source_security_group_name: typing.Optional[builtins.str] = None,
    source_security_group_owner_id: typing.Optional[builtins.str] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a21c9d7bd7156fd2dd5a288945bbf548f4ab7a9ee07ba36ecb2062ab615ce325(
    *,
    group_description: builtins.str,
    group_name: typing.Optional[builtins.str] = None,
    security_group_egress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.EgressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    security_group_ingress: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSecurityGroup.IngressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__995a1a5869d618c24a624831b2ad5e725b73ab6134ba003d66411c58faf1187e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    state: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__856438104299447428cd955093ead73bce11b3f11c039205bcd5e194beb9b322(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5986589d73c46b7a96fd8cdffc5dd783512e594c0f96cf249a7577ed130d1c96(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a4c8cd7c082b41fda937b1f6a6a1a59e489b437d498c2b75a58ae1582086af7b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e66d65de803363af49ef406b4229988fd2680cccdc692b106aff40a80ff135ad(
    *,
    state: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__507ab221d4bf8e8520b22850e0df945eba1ce8da26b5b5f4800e98249ec0bb9c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    spot_fleet_request_config_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetRequestConfigDataProperty, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b956e8943bfa35327db536994b6edbe089284801ca3e46a1082facfee29d79e8(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29e928bf0c0a765c31ed1aabb95ddb547b2caadb528c87b562c330345b3e0bf5(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9c164a161df2064007e11aa13f2fcdc69c4d526147241ddb279829db7e4c08a(
    value: typing.Union[_IResolvable_da3f097b, CfnSpotFleet.SpotFleetRequestConfigDataProperty],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9450177c100960250074c89d88e9a91ffb7858df09cb594773cd480253ee8cab(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad298024f0d66aef3de35bb7901254b09e0382ba2e0fba90cd0884eeec9bf9ec(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9ce4579262afb56f65f3c52460d38101dc8cc8042547f0bd533d017fb03704eb(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eaf57c5479d93c1d582f3d3d29acc1adcd3859e499d942b90078c476602172fd(
    *,
    device_name: builtins.str,
    ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.EbsBlockDeviceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    no_device: typing.Optional[builtins.str] = None,
    virtual_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca150b39fa706ec4abd897598b47113f9d45fc9daa40116380b828426e9643f8(
    *,
    name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__239f11e515811c4899eaf71cbfdfae21b9e614b8afcf11b03fbbfb25f04b894f(
    *,
    classic_load_balancers: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.ClassicLoadBalancerProperty, typing.Dict[builtins.str, typing.Any]]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8886c06b4b6ffc2fd12b358b844b8cec0e460ac72bc835d6e99c49fc6e885e1c(
    *,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iops: typing.Optional[jsii.Number] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    volume_size: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af9cb9b64f5ef928643d5b676c935d9144d03fc2ffd12d202da6e2376578ded9(
    *,
    version: builtins.str,
    launch_template_id: typing.Optional[builtins.str] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__23f8cbedcbc81ac996a29ec029803e6448e5fe8574e2c7eb1c67691089c43fc2(
    *,
    group_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad379395b6ad9c3fadde77347a260722b64260ea5f6a5d7060f20bb3613219c3(
    *,
    arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__be30e0d6c51e88da62517809d0c34c5193aaa5230acd3e38cf6b199a62510f5a(
    *,
    ipv6_address: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__159c47cbabf4008a2d6031dc275207d35cce8ec84e13fa89dac46cf0476fb179(
    *,
    associate_public_ip_address: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    description: typing.Optional[builtins.str] = None,
    device_index: typing.Optional[jsii.Number] = None,
    groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    ipv6_address_count: typing.Optional[jsii.Number] = None,
    ipv6_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.InstanceIpv6AddressProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    private_ip_addresses: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.PrivateIpAddressSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    secondary_private_ip_address_count: typing.Optional[jsii.Number] = None,
    subnet_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d87a87ea48430983e2d408471599b12b60b4f49c59df11756641689dbbc395ce(
    *,
    accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.AcceleratorCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.AcceleratorTotalMemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    bare_metal: typing.Optional[builtins.str] = None,
    baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.BaselineEbsBandwidthMbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    burstable_performance: typing.Optional[builtins.str] = None,
    cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
    excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
    local_storage: typing.Optional[builtins.str] = None,
    local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
    memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.MemoryGiBPerVCpuRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.MemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.NetworkBandwidthGbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.NetworkInterfaceCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
    total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.TotalLocalStorageGBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    v_cpu_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.VCpuCountRangeRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d0ea174aaaccb24bf422f5f66f8ba4e6a263f8598d78d32532eeaa8bc3b949a1(
    *,
    launch_template_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.FleetLaunchTemplateSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.LaunchTemplateOverridesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6881721673f4b31b8628e6827d756f492af26e7020e9cabef8ef937b58e786ea(
    *,
    availability_zone: typing.Optional[builtins.str] = None,
    instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.InstanceRequirementsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_type: typing.Optional[builtins.str] = None,
    priority: typing.Optional[jsii.Number] = None,
    spot_price: typing.Optional[builtins.str] = None,
    subnet_id: typing.Optional[builtins.str] = None,
    weighted_capacity: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f21bd7eeb212de6045174d1b4425d8e8a7297d540af3851035fd520408fc3149(
    *,
    classic_load_balancers_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.ClassicLoadBalancersConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    target_groups_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.TargetGroupsConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e4475705f4e7446f3705401f8765729ad5a54f9335e190b73b27d5a93e4b2082(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__acc9c3c15cf6764adad644b17331efa0014c4cb1b01cbca0fc8810287bc3930a(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48acefcfcf4a24647056db3b94a5565ed7614642c316eb730eb0c315d2226571(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9f1c2a58b07974c9e23679ec83cb7b814966f49625f30a69b4cc73039ed7cc1b(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3fbf82fafbeb8256df96bc5af5ab7495e0fad3c525a6e21c0558c4942e59306(
    *,
    private_ip_address: builtins.str,
    primary: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__087c5e29b3a83067d823c986687f65a3448b4855906b3849664607c371191afe(
    *,
    replacement_strategy: typing.Optional[builtins.str] = None,
    termination_delay: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2894b30d6a2236ca5cb1a1d15ba8bc5ef33a3ac03eef681d6f01a792d338765(
    *,
    image_id: builtins.str,
    block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    ebs_optimized: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iam_instance_profile: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.IamInstanceProfileSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.InstanceRequirementsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    instance_type: typing.Optional[builtins.str] = None,
    kernel_id: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    monitoring: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetMonitoringProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interfaces: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.InstanceNetworkInterfaceSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    placement: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotPlacementProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    ramdisk_id: typing.Optional[builtins.str] = None,
    security_groups: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.GroupIdentifierProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    spot_price: typing.Optional[builtins.str] = None,
    subnet_id: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetTagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    user_data: typing.Optional[builtins.str] = None,
    weighted_capacity: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d656e3fbe7f2125890e405b7fc3a48da1eda305699c018bc23e23df2b093e134(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96e39e67c39e4d79142080d6f0ca11d1deb92976c2e01dbf2167274e9004285d(
    *,
    iam_fleet_role: builtins.str,
    target_capacity: jsii.Number,
    allocation_strategy: typing.Optional[builtins.str] = None,
    context: typing.Optional[builtins.str] = None,
    excess_capacity_termination_policy: typing.Optional[builtins.str] = None,
    instance_interruption_behavior: typing.Optional[builtins.str] = None,
    instance_pools_to_use_count: typing.Optional[jsii.Number] = None,
    launch_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetLaunchSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    launch_template_configs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.LaunchTemplateConfigProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    load_balancers_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.LoadBalancersConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    on_demand_allocation_strategy: typing.Optional[builtins.str] = None,
    on_demand_max_total_price: typing.Optional[builtins.str] = None,
    on_demand_target_capacity: typing.Optional[jsii.Number] = None,
    replace_unhealthy_instances: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    spot_maintenance_strategies: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotMaintenanceStrategiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    spot_max_total_price: typing.Optional[builtins.str] = None,
    spot_price: typing.Optional[builtins.str] = None,
    tag_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetTagSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
    target_capacity_unit_type: typing.Optional[builtins.str] = None,
    terminate_instances_with_expiration: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    type: typing.Optional[builtins.str] = None,
    valid_from: typing.Optional[builtins.str] = None,
    valid_until: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f35f2896caa0167d6333a92f1df926b97081f631b578435e4340f30e78b1bca(
    *,
    resource_type: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__358912d3da8f0ef48490d3fcfc7e7d25ac4bb9de14819d26fc6b0dac8f2cefb0(
    *,
    capacity_rebalance: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotCapacityRebalanceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bfa50300dd4a5a936d14fd7c5333917be6259780cff3172591f4c4bb46066959(
    *,
    availability_zone: typing.Optional[builtins.str] = None,
    group_name: typing.Optional[builtins.str] = None,
    tenancy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cfcb40128ba9ae2ad293302d89e5aa4a53c03cf29c409d83d0e67338adff73ec(
    *,
    arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c745b802ed9970f7336f102ee634cf183cd84857b9f739bab7e9b66f7ddc4a3(
    *,
    target_groups: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.TargetGroupProperty, typing.Dict[builtins.str, typing.Any]]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__06acf1d43569866b4e132737f9c0f5dc5a8fb8a951ab042576f2122de8f80e6d(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd3a984fe26c96a263a4ba0c4b1343feb154e583aa8ce45faba1dfa139f1b05c(
    *,
    max: typing.Optional[jsii.Number] = None,
    min: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9ba1dd409c9f6c2b307a2662c74f48716ccd437f87094831130aa4d0f583a5c1(
    *,
    spot_fleet_request_config_data: typing.Union[_IResolvable_da3f097b, typing.Union[CfnSpotFleet.SpotFleetRequestConfigDataProperty, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3552c7996fe8d37a6b035d9a3032e8c21e885c6d2abd5a0f9ff377ae3a0ecf57(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    availability_zone_id: typing.Optional[builtins.str] = None,
    cidr_block: typing.Optional[builtins.str] = None,
    enable_dns64: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_native: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    map_public_ip_on_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
    private_dns_name_options_on_launch: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6156a193ebc4d0f9f0b05548058061d243acb636c512c72051b309b52a9f9eaa(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab21bad99e8fed59878de9a3c0dff4a9b147ea44572c7f6e3fb94c9ccdd5b5f7(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aad08d53a3fa5bb493bacf8cb9e5444c7c29dfdbb7ddbf9edf8e698012de854e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__749bdee9b76dfa9816b5a3125fb8ff25ffab41bfe67e30d6997e6c906f70c8f5(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d61c6c66cfcff863e99730d3fadecd08739afc1e6fe72df9f8a02ef3a30e4931(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f88760ade883243269d5a16afd27db07d159b6822400158d977bee60187cba60(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc4da08e39eed40a229643cb7d351ca4ddb8969c310ff4a588bf2f9b2c57ea2b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08fffdbcd6d1db1ed3c089b63fe6c0aa0846d345c3d53724dd0545885b023517(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e1b0157b33b156c98fb389fde191897914b633e753380d212dced9fb14a5522(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed3081732b603fcc8ec9ebb9564e406e2e7472952031d76660f9757518d8e0ad(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32cbba39a8e77a22a9b46de57faddcc0bd138b522049dcc5b72fae1f010dcb6a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2924466543968587848b6c9a3abb9e410e42b51b663f080070f7b608ec34461f(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7d9766dde41d5681123bb5654fa95ff2d630c4e00a04381c5cfb0a75bb33ab6(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fa8e8ff9fd2c1d32daaa28eaaf1a657bbae65ac881e2d64fae17cd5620a8bb2a(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79c0c96a0563a13bc67d2000e0d23b07922c04c49b66b0f017a1d3750266a111(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1176c1fa68c8c764e85625e34f7177136204be31a2b8e4fddc47f3513120b75c(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1411603d4698ad667b7aec511028a02a96d43e8378e3f1f2300b1c77c6b00fc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e13366cee6d454131332273c13879e73090bba06a29c362064c8fb55fa666614(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b297663d31b5bbe92a3f56911eb6c57abab4c122a855b348cb1da68bcf50efe3(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9ead2dbf33a2462f22ec4fe1b542f6a0fc766e914575dd0c8da36b35e6a471a0(
    *,
    enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    enable_resource_name_dns_a_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    hostname_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cea972c46cc6b50f26ade1aeb13ea8427be0dcee4ec5ef424ab06a54f974851(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__81545e5ad3988b846e1a2818225195a63d3d514916d75bd48e2c13c7bed235e3(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7748afe0f6471ee19ab5901ad409f669a3f3faf2ff7a9355b237ccef73272a4c(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4efd57f93a642c14210500623dadba0a052ecf5f63cdd81b7da1517c743193fe(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8a93fcd23cf2bfc75bc22656ab89fb6faf4261d84c2b56613bfcd5f45f8d8c17(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__47bacd49bbd20a576e8606ed6d9c47edfc3f6de53d74312f66482bd773de9e93(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__452e13bfbef96c8acd7605d4b366122948a9d1a1a6ea7aa8f96dab339baea0d9(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__921910fa5abf704ffe5d8790c2dc76e78950fd3fb2bf752eed76bf90f1024b87(
    *,
    subnet_id: builtins.str,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85259f8a3e99ac9118a42a8d47888848ef4038d0875782d7999e412d88e08e49(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_acl_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfcd7cfb671f801b9900bd757e22bf2ef004eae956d3db39783c929e666c99a1(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46741ae4382fe5da17191998ae3a27c6d9d2f7aa50f33a2c9d63bc5ca20ebd0f(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5cf968b4e7c1d6097c91b50633033f355376ba0c50b179c88b61b64419ac35f5(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__20de455202a2a20f984202966e9bd377f01da603283f59078646c968d52ec14a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c0946d220fda59f06b2de56a738afbe1371347d6dca68f5b624f6c01802e1320(
    *,
    network_acl_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35feab8ee8f0aeb1dcb5a7eb3df1cde58a61806467c8cc5f249b6acf5c54da22(
    *,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    availability_zone_id: typing.Optional[builtins.str] = None,
    cidr_block: typing.Optional[builtins.str] = None,
    enable_dns64: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_native: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    map_public_ip_on_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
    private_dns_name_options_on_launch: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__294c1e9f851a710b52055c4f95268b2eb5d074c4d171e81323e769d40fa7aa03(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    route_table_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ffbed3c635301c3dd5e86e308c08d9a18b5a7b7b9854af76a0205620cd2a9e00(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__22bcaee54b84824fa37f45bc532da947376d35a559b7f05c9f82232096b07dd1(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5b81a44aa8082896b06b0d035fdae44f5a718c027db2e512155192468e0f69c0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc32529a14292116d1c9386ba1f02c8787852edc420a39b64cc810ef446c60dc(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__59925cd44b90933fc24031ecd6f926df6d2d62b0406726dd75f11833681a80db(
    *,
    route_table_id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3010c8c23523308b937b13bf2fd061ce50421e19e699a33715927ea747a36fe(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    network_services: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4139de6cf862ad5d74c52e241eee09962b6e2d2983b38ee7d69d9fa4f3e2626e(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9796f7c469044aefb3cc59e55ef7c9fffbac54c39bfa4d37ab4526f3c451b021(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34c87f41e67e3d2c9ece9a99826b4a349e6793112061a31f7e0d295aa75c9bea(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e14bdc88434e1d710881affb7ac0701cafd52b3833e3a79e069b66fa0adb72f4(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f1c9440946dad085b634913583179ecc95e0af8128310eb6f018e4709297712f(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc240768174256167e14afa8be2711f58bc36134a0a78ff17c568c834caed61d(
    *,
    description: typing.Optional[builtins.str] = None,
    network_services: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d31a4a58c039ce2bbc135b28c273cf97fb8d472640a28e00ca448193911be99(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    destination_cidr_block: builtins.str,
    rule_action: builtins.str,
    rule_number: jsii.Number,
    source_cidr_block: builtins.str,
    traffic_direction: builtins.str,
    traffic_mirror_filter_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    protocol: typing.Optional[jsii.Number] = None,
    source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__44d0755d06bfcb59329075440a91d3fd073045ea48cde80da24a13d27fcc4ace(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__530a255beefd02de60d367c9ac1d668826efee3c596db923d734ff2e5a007d47(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__453dc5a585f45610d480b3d9caac41d113f3861c3984c740384a3f9b49017cff(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39ae22e971058237f4c2b7a3c9b290cd06a9d634d0b9fbf10881c6447ba16534(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3dfdefe397e1b467a4cb10154878fb4e8b2a4992d1135f0e177f5955c7301c7b(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12766b41bee664bd087eac1601526fefa89d9e302e018b00fd16a01d0a95120c(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42efc440f02fbd964f45fdc23d5d014c1db094a539ea68f5618320149e3b23d7(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__98515aecd50906470f8454a919491e01c343040591ae34b9e141b8c7a9dcbb97(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__521df83e7440c469be09cf04526f690bac9ea4f5cce00bb63cb6afc0dfe5f410(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c8951d72c6da3ddb59a85b44d76acecb81a501942b46d41d45178190e8993c70(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7405e6b85e9ba2b1c567ca1522aa3048bd85acb3773d5cac79ed869a4da5a0fe(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d40ca05dc02941bd4e8428fe96fbea734028207b51cc90b1db404cf019650b1c(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9be5e236a0a787f81c7a17c253ae7c6c2e21e13d93a6f55bd8a2d0a9e42cecef(
    *,
    from_port: jsii.Number,
    to_port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6d4d280ff7b483a33d845d48221597161e1166fa2e705738c6aa067763329bc(
    *,
    destination_cidr_block: builtins.str,
    rule_action: builtins.str,
    rule_number: jsii.Number,
    source_cidr_block: builtins.str,
    traffic_direction: builtins.str,
    traffic_mirror_filter_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    destination_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    protocol: typing.Optional[jsii.Number] = None,
    source_port_range: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTrafficMirrorFilterRule.TrafficMirrorPortRangeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e0df29e9de2cc6eed997cd0738e89aa6fc9bdffd0c700ef4584f2c9e0a82bb8(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_interface_id: builtins.str,
    session_number: jsii.Number,
    traffic_mirror_filter_id: builtins.str,
    traffic_mirror_target_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    packet_length: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    virtual_network_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d7de9b275c66d169a52141d4946af458aa37cb352101d9d285be17a4f8127775(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5175b811144be72e2972ae8537d98f6781fc67b9b4b511fd17c185da6b52b510(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__88364a9ef675f46540f613bc4cc3f9e508a3c84e4ae23f262224ea0da8b0a550(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29177776de9d50bf58263ace2dffe1059e0461b4367b3472815febcea6d37035(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8bdb9ebefe44a551d25fac218ad2fa7a08d89dfeb20fe785cb28618d28d85f64(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c749c7fc0935214e5efa1d67d38f275bc4679b3217cf7ef8c93259eb0e9f861(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4239210691e02d4eea905b9be001d8302bb77db3dde61743cea1aa5b6d2a3adb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9aaf61851419d979865e5ff3ad332c3b90ca87f0fd776502a722e2ebe1429297(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9cef8de482d63e77fb4dc5a3633142e1ab76a00eec80854c5d9bbd7390fb5f1a(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e4afaa938b95b8222db16ad536740a420867628edc8874a81c78117a7d30a9e8(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__410c9163482a74952290246bbd3c364855d8d943a582d683fbe831b279cc26de(
    *,
    network_interface_id: builtins.str,
    session_number: jsii.Number,
    traffic_mirror_filter_id: builtins.str,
    traffic_mirror_target_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    packet_length: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    virtual_network_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__70ed5196cebe14b98a0bfa7a8c8b551d0ff3f3ea5d39ad701b844d631ee5f5f9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    gateway_load_balancer_endpoint_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    network_load_balancer_arn: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49dd29a3ac59afe75d377125f6f9e1efacc539e3e7011335b7aefd19558be691(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__821abe97977d9065ae17ba3689f3ebcfb2870f85843446072880333869b48c3a(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbfcefac30f45571dc267f516f68fed7eb6e0db8a5c14e752682147282c313ab(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__104a6fbde32b1c4fb2e881070de0dd6d5a689f6fa4b0759a1977dbba27ddf990(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5dd0de64890549ffacaee1e73ac06cea8ed5873474d59f91aa3c31d79b2de33a(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__534c2f4f36ca1428397aa3d1d19afe134f4ef3241c04fd666698c4fafebefc59(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87ac4a1681abc492ae8bee1fd3764a93017519a9b19f62fc4ad2099d9ba48c93(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83eb5785ef7f80ecff2d793495ef05125c400dcec136b602834d403b53f91776(
    *,
    description: typing.Optional[builtins.str] = None,
    gateway_load_balancer_endpoint_id: typing.Optional[builtins.str] = None,
    network_interface_id: typing.Optional[builtins.str] = None,
    network_load_balancer_arn: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bba1945c40ffe23ea319a1157d643d40dd9ada3eb2884ee096699e54979ccfc7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
    association_default_route_table_id: typing.Optional[builtins.str] = None,
    auto_accept_shared_attachments: typing.Optional[builtins.str] = None,
    default_route_table_association: typing.Optional[builtins.str] = None,
    default_route_table_propagation: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_support: typing.Optional[builtins.str] = None,
    multicast_support: typing.Optional[builtins.str] = None,
    propagation_default_route_table_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    vpn_ecmp_support: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f706d2be5763b7ea9cc3a860496bdbe2a371e281d746e0368dab2a6e4cb9537(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72ff58700f4827ac68ac9f42abe54b7fc28d95c1a7d59fa84f04db26f93256cb(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b46c1015641c6edb0bc297526a4064793b9e88605b3212dd0441b546292678c5(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__932b4e28bca7c84b0f853908182e3c0a62a82ce26b539df207c870e6764698a8(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7aa5bee9d95a5d078006432292f402d76b063679b39dc0326a45947bf157355f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c1e89cc250279218430f64dcd73ca74122a1a5ab134a94e33b088fe88482cf6(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__126744879944d00f0dc7a54fee23cb014756b685c183a2d78932627db1e3deec(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c73a285a2d555dd54da4dbf2184b1382397e84bb9103e210bbe3f558a877be3f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d5f3d15ac6d140a64177826bd00ab6cfa60d0860fbf0018422b793d774fa5ace(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b6fd0b36d4c60bd1f6136b3f8cff6b7319a43959272b1a770525b5507e6013bd(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96eb40466e83d16bb71ed5f295e56c3ec41178edaf7dada2d08c5cfbf11b20fc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ce7a4c126005c51509a0bd7f2c9b3dd762ba3bd0c8c5a303dfdcdb1ae2aa45ac(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3c559ff74e846d70e5cc985077f2c0d0476db043c3f6210c18ed96783d61ebf(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1baa174f73ad52695d79d82af5563d4a38cc3f7ba388cd069fb17240a549ed38(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eab8e96bb64a927b52383e2a842bfca63a3ece05b571bd631f2c4d980838f426(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_ids: typing.Sequence[builtins.str],
    transit_gateway_id: builtins.str,
    vpc_id: builtins.str,
    options: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cca20a7b6f10e5816fe3b6b1b7c269fa3848b7398e1ad9328f33b3141cddc8a0(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba3a3854813c8821446ab56c6c0c0162a019d23262e8cabaae93972eca57cd4c(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2cc237d43b6ab6e6acbbc422259968ffb5964e270b148314d969fb42c425b873(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__43e06e177eaf3151f23dd642b85bb7c527e74603319029db9a9f806f64dc4a70(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__721fe039d87e2e2ec45edb1476e9f8525a159282ccb9acb06a793192bb2cd6ff(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3ab60b7cc3369c5561ca038826e38262fc6d63a986ff59a5e3fe69932ff2a4d0(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__826b56d4563bcfd9f8c247a5fcc905fa7139b5b0f5f16b21b6bdd9ee74befbc7(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a6a91070bc957616b318464b989714fb81382073cacd0ab2b00be277236a29a(
    *,
    appliance_mode_support: typing.Optional[builtins.str] = None,
    dns_support: typing.Optional[builtins.str] = None,
    ipv6_support: typing.Optional[builtins.str] = None,
    security_group_referencing_support: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07286507bb35af9dd738df090e52540130e6551e84dffc04995d5dea86a6b97c(
    *,
    subnet_ids: typing.Sequence[builtins.str],
    transit_gateway_id: builtins.str,
    vpc_id: builtins.str,
    options: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1eeb889478aec2b3809f8d0f9aa281f4c3364eeacd9a24d491a895919f93be0(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
    transport_transit_gateway_attachment_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e834e78fae3188c121864fe170c35cce5c93a961423fdfaf6c4984a3ff1f3d5d(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3470664364cbc2bea67fd850b91f5bf0e8554b7f696d69ca538b2781a52d0e39(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f94900717c95bb6994e0b373a679236b76d90c6840a7c302377032733318cef(
    value: typing.Union[_IResolvable_da3f097b, CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76ac46a299fc52743f1e23fb957186961b3558b17e48998d3bbaa8039e98383d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b237c6b2758193e6b7a3c82ba11a22ea4f505054d8f95b271d5b3aac76ccdfc0(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f28cf9493a9ba4af846e6c741893e0f0824bc477c2f1963741643adc413766d3(
    *,
    protocol: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae4b1efff7cf5a4fab7c16d5ffad18f9c18dbd0d23dd3fa072685e3264ade5e1(
    *,
    options: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTransitGatewayConnect.TransitGatewayConnectOptionsProperty, typing.Dict[builtins.str, typing.Any]]],
    transport_transit_gateway_attachment_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12d9bae5c632fc5f2e4010c8fc9c73ce070047631f45ed391c85bafbebf8fab3(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    transit_gateway_id: builtins.str,
    options: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5866dec7826d5bb1b5fb131f6f8fdc1860951c1171fac450128c46dfb15c9239(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f8c6938f04ffa9c4a27f0f78a14dc7d72c656d8fd8e1c29e4cc654e39bfa838(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__56ba4d60bd49e9d2b00ad7a61667dde0b5864131d85ff7aec7779d924936457d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc15811b4637c83850a22de14f995dae019e06cceeb500bda4760e1f88ccd349(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__370c22228824f814c2fb5c861751b56345c371829d3c1aca9ba5d3efdfc4787d(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc1dbcfd21d6f8129cf25adbd6eed61be19656a68a6ef09c7e5a8772bf5b032c(
    *,
    auto_accept_shared_associations: typing.Optional[builtins.str] = None,
    igmpv2_support: typing.Optional[builtins.str] = None,
    static_sources_support: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aba86311abc72a866446901528f0c54660c3faea73c8df278db0a6b6d3a3b2b9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62f6377db8127d6632b039d487c4b37996f466cdb9c086529970b35e61c58ba7(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4237d038461e8761bbfc04b590f1b62ab4e7c3738ef4f1de609b9a0663561870(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f62547cbe33042979a90f1bccb2f6fde3c8dd8542ff6366ad8affc3fdd4c0394(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__868fee90caf8adf36048078bdf631831c3a1c5e29bb4627fee76012226800583(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2680948d048e1f72a4e73ba487b2614bb6eb02bdd5e5edd3614df2ff05caeaa5(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3552eb0df4cf839ac449cb4b37583397c280fb505107205f64efd6cc374816f(
    *,
    subnet_id: builtins.str,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82230ee30d4f656c56dc4f383195382be24ba4cb84a6769b37e27109627859b9(
    *,
    transit_gateway_id: builtins.str,
    options: typing.Any = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__99bbc4a729c6448f66047a945b6965b023880f37f56ada02413a5bb67cb9d13e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    group_ip_address: builtins.str,
    network_interface_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c097197b61ad3a7c542d59d643e97e2cc1c1ce371f1094720515cf18ca39c717(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__80c1403a7c86ad1151669cf1148863c486b7c655147ad39e2241472a0fcde771(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__78530d4f8b5c66188b11c6b16950cc4eed614d73f18d2dd84182bfb961862baf(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7af02059fff2f36e902ab39c08e172a6e2b18ace987c7090f265862a4b889281(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e77f7b712c4fc75388360591aab231a51b7d7231aa3b157ea9ee7598d203ccc8(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd70ba7cb3d2a5746ba2a553a15b9b126ff0ddf756b290927849ef2f3397e093(
    *,
    group_ip_address: builtins.str,
    network_interface_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__033295de69faa0f195767977908005970da4276d079a9497c1199df0f8a16c25(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    group_ip_address: builtins.str,
    network_interface_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3e12c9566f12b9a0a3346bc3093457a98b4487e8553aba5952f4e7a130f8f74e(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b7c375fcb6e9903091c8860559bb5b928ff22761a9e539f7bbf4589848665708(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6498cc6e10a5b77ffe78f41417b966098b903080b2a6e7d3e00cef7a020c9ad(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab6436f7c85afaad9bc4d97cbe548d3fafa4a5784cc1cbb316cff4db39914539(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d0dd53c8c17c01151422c89f930137b2690bf7fe5921e99a47facf4825c4075c(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51fd02bb3cf11b7e0f454e3a7a3e40105c5cd8b9be4cdf8a76b1203549d056a8(
    *,
    group_ip_address: builtins.str,
    network_interface_id: builtins.str,
    transit_gateway_multicast_domain_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58337585cb89e7f01f2f50074e196aeb221ca4931847f4f774499705b5b35fd8(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    peer_account_id: builtins.str,
    peer_region: builtins.str,
    peer_transit_gateway_id: builtins.str,
    transit_gateway_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a5484bbc750180ce100bc804b4dae3e7ee77aa25ec433001612e49c3d0fa23d8(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b558709a9876b2f9187525b08893d9c4639b71463ec4fe23054c03115219b259(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d86882413a5d67b4b8f9d3972f68fa0b4000f6a38c663786d27105de7eaa82ee(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3153fff3ae72085d503742fb48a25c1343bcbc7312bff8131485df03e8a429ed(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__742e838e1128a9b5b4944ce0e33653f15a4c48a8e34db83202b2c6ad727d2e28(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf14462b6be63c62e19ee63dc199ef02d6cdda10ef2d6938bd0c455e676e87d3(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d52cd680317a66c5009e2e4fa9defa1bbb3dd9788b6d34f1684c63a8485c4be(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__402682d9bd66852b5382ade3d50e18ef97fa5a0a5a922eda3b43c8a76a106784(
    *,
    code: typing.Optional[builtins.str] = None,
    message: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__77448e48b8cf8aa3a47158e6a9f13835a48a2d953e7a008d85d4ad77353438ad(
    *,
    peer_account_id: builtins.str,
    peer_region: builtins.str,
    peer_transit_gateway_id: builtins.str,
    transit_gateway_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__49fd996c8de156c654fbaab604bd7c39350335d42f26ebf85fab17421d12904e(
    *,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
    association_default_route_table_id: typing.Optional[builtins.str] = None,
    auto_accept_shared_attachments: typing.Optional[builtins.str] = None,
    default_route_table_association: typing.Optional[builtins.str] = None,
    default_route_table_propagation: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_support: typing.Optional[builtins.str] = None,
    multicast_support: typing.Optional[builtins.str] = None,
    propagation_default_route_table_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    vpn_ecmp_support: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__762528618652de53ec01b9db873d15c1412ef510b68d36faf8e5193eec412419(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    transit_gateway_route_table_id: builtins.str,
    blackhole: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    transit_gateway_attachment_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6fe5f8903bb547777e371b24127245fea55b6701396307b362c9f6bcd40be6ea(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__db248da6e580b35319fa4105c6aa56b32a97434942c5e6aa6364835dd97a2da2(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a3ff43d5668d80486662b5f29a818edf8b7a164143e8327503af53fea81d72e4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae3c350b4ebbf2eafd4fffaf648073580cc8872edfcbb0622e12224667970a75(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30150d874e802337a21fe5c33c5e59055a33af9ec33282c5c08706bcd1082c1c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a94dba0eae14b14a0b432cb7e86de53fbec80e85adaa717d318a1fe9f54f5a15(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__234e56a6f757b6cae89b22252317937e5caf6081f899789f9dfaf239987ad5e3(
    *,
    transit_gateway_route_table_id: builtins.str,
    blackhole: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    transit_gateway_attachment_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c7db50f4ae112c57ab046bda7776d377180bab25c5b7569cfacb2c8fd614844(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    transit_gateway_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d88de7ca145b9691c5f4568e02636aa128bc669dce28368c24b0f50acbf21749(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93d1caddf8f58dd830a8b1a8588a6e19085533263b68967e0f81ecc59cc99e29(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5290db479c4c53b82c25594d079582d552d1268cad24e1cfbd7651525fbb11df(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__43aeed96c5f9dc7ad9fd30a7b025d18beeafc24b1e18d45dd7f55535f13a095f(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__78f986e9d5f6aaaab639684e8a0a0fcd849e66ee5753c55924b5eada37d47009(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__116daffc777588d4dfa146f91ca3900babc69bf1e2175e3ad761bdd21884e7b5(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08b6fb4f1eaecedb0dfe89b77727aba1e81188951720ea798d7fa437604e9558(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5543e31dfb20c6968b1e8209ff4712412a0d6c761e4ea9efc49f5770988c52d0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74675d79a411337f3a445f03fad9f4be2bd700c99ec19055fba1046f2ed4a907(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4829b3291359a71c64898c4281f04e83bed2de8afe12ff66a4133e08152d9810(
    *,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da858a31988874f473110279ec5eb87449e233a3ebad68452008972c2f671d23(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d5810e45fa905e8749c88f944f6da27be097fce5be9b460b8f4f7daf3be4a6e(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82640e3148a89b50ab9fa60ce3c86b0e17db3d883834214fff5e89af89d28710(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bf4acf2c9e41294be87e18f515bafd4da46d18ee8cd9a84954cef588d027cee6(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b58bce0f83d6f5219bc4748ef214de49ff2150073c9cd7d3c6dd566f5ccff2fd(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1001c0cdbacafaaf2659cb8ad44ad98feae866d7909c2d8fe15588f9385bba8(
    *,
    transit_gateway_attachment_id: builtins.str,
    transit_gateway_route_table_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__624ecdc1b51b6d7cebc10c5a14a95ecb834135c841993042fc7676de30a6ecfd(
    *,
    transit_gateway_id: builtins.str,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d109d90c87450f0637894d56c9ee177e4beea437893a966e606a7dd2826860b4(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_ids: typing.Sequence[builtins.str],
    transit_gateway_id: builtins.str,
    vpc_id: builtins.str,
    add_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    options: typing.Any = None,
    remove_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9ecc0d93af1c8489c4bbda700ff0aaa17993b7f890387763b61be49a669634f3(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8dbd974ae5adbe7b1ad43ec624c5e026d9e8e738560ca2db8fc4cbb519566adc(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8824c05960be22a88ed38a1107dfdda1b7a33c1130d7345cb45bd41fa07e6fa1(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__64125fcd948a2b9a2891c0f1b735612475a3696e1e1a6ce222449d816847cf37(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e587353a349767971e5cbaf158300eab82f9bce2692398042f86c980ae2c528c(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__afc015eac08ef29fff8117c42a6b139d4590bcd699d2fb2a9fcfe014bcf849a8(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e8c626c0d6f1542c9973dab4d553c5913bd5993d5ed06bf53b5e4da100ed6536(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dee422a132fe5db433448f7d65a42eb23ff4421e51273d7fee8cc820f6191ebb(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52ea672c76395c2636652dcdf3a840ac98008f0aaef840e1c4223288eb7758ea(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea53e7949c27ba728a0fa1f4b7f62f321894de9f55e4d88a106982259092207d(
    *,
    appliance_mode_support: typing.Optional[builtins.str] = None,
    dns_support: typing.Optional[builtins.str] = None,
    ipv6_support: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5b00816ee380c391f9918e8b3c6ac6b403ffa259db4a3b55f9792a5841c334ec(
    *,
    subnet_ids: typing.Sequence[builtins.str],
    transit_gateway_id: builtins.str,
    vpc_id: builtins.str,
    add_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    options: typing.Any = None,
    remove_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__652142f8451c882a92006b3da83dda7c75035b0e67cfdb89b2dafff72755d8a2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    cidr_block: typing.Optional[builtins.str] = None,
    enable_dns_hostnames: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    enable_dns_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    instance_tenancy: typing.Optional[builtins.str] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a3738c2c36e6ee829580f25d486aedc44b115450b8ef5d1ad87f9e8ea4c37f38(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e488342c955b8d1ac0d4c25b5ef0a38de7c0fb0c580635703e6a0b5431f3a83d(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6676074ad3966d5d24524535dac1f0683a56ce312fe3dc7ec544a0708301ad33(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76b1c3d147ac864c2bd493d268192b99f69e4ff3aeb1a1783954d1efa7c0ecce(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3645a4a353e587b21e1cd795ce82fc78aaea171258b387dcdf1e200a803e1e2(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8d65d530ea680bb10f086d0fdbb0502a13ec6eeb42b29a710a3e6989798916ea(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4392bec5fe5fed25dd76667fbb47dc0e42ab059f7936a2b1a9e46b33b769665b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__05091c2540acdcbf2cdc834f826aec0d6ece2e369ff306d4303712dbe07cdaf1(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48b11f5a9856584abde78ea8179ea1e15a79daa88103bf860d8cfd4852cd9b39(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__183c6879cecf5e6ddd997bbb9856489efd89dd91a20b0a897e4a12a459346d37(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    amazon_provided_ipv6_cidr_block: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    cidr_block: typing.Optional[builtins.str] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_pool: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__55e11c04fe82c2d36be04dccd85d599b2207e3c1f84f30fa597f5c0679365f56(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6deb753808a5dcb816815d58d46520df4de2a31856a0dd5fec1aa63dd12b8b5d(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1eb2368232a584720fe24adf42f2fea5d0dc555e4ca50f2e83c3181cce67df39(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67e064277194f0ee630157d4f67958b8590b71bb2baa9f6bd024bc4ba68b8194(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fca66c2b1e9d0fbb7d3746ec42b0c68e63b54725b9fcc33e8f9332c1c8a5ffa7(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a8a10519bbe642c76098123b41f05c0e927d67d2e9cf96fcf1ca647e7f756d1(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5fcd7e03b583fcf369c24b9623466fd52788b1fee99e653c567014f4f71383d8(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2efd97c3af41c8a8c16797aaca56cbbacebc3fff0fc5ec71d75cd3d0c44642c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__90a5a1f83f5bbe2892474aeba0dbaee518350d03fcd592eb44bce97ecc24b6b4(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d003bf6babd2e3fda2c716a6c7e74ba83d0de8a16ce7bed075587c07683adcc0(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e1971ac5759a7e790f834281baeac4f3a29bd93d7dd0b5b74f6f6500cfccd21(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__55248a04c0e8026131066b5c27e0e5fd8fa2cbce8f31b88e00a3080d92a0279e(
    *,
    vpc_id: builtins.str,
    amazon_provided_ipv6_cidr_block: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    cidr_block: typing.Optional[builtins.str] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv6_netmask_length: typing.Optional[jsii.Number] = None,
    ipv6_pool: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b9bb034214f5dc77d48f0c0859b46782ac6d39c672cbdb5f28f61b41965eef4a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    dhcp_options_id: builtins.str,
    vpc_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d3ff1830cb5525663a7a195e9d7674f4ede7abc671337ab6826874c27ff24255(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1575a3d3c0b16382fbd67aea32d49e0b4a40a67d295511829a1d82675e6f0b5b(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1707945c06f70798e93e27d60ab06bcd4ba19922e8976b629c925c917a0842ed(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__91e8d4b49f9afbba3e84350c9a368e27d6df44ac5ad18319ebf6aba61a74d810(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d233a95be90ec03e2a21cfd188b456c080aca97fc6b8cdfa321e42b243810d4a(
    *,
    dhcp_options_id: builtins.str,
    vpc_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a16478d34754d994e7b5d75d1e427abd720d7df3e6b3c870e3e83c927817da50(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    service_name: builtins.str,
    vpc_id: builtins.str,
    policy_document: typing.Any = None,
    private_dns_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    vpc_endpoint_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c54b99dd0fd377d6fc52123dfe3ad824e1fb2e886fde2b0c922a6483aff148a(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8180577e06d5f40db7bfe860861e761a322315b93022f1003a828f6a78b29f79(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2090beb1c51f8f71e8d917867bb4a45a0f3f15917f6cca0b5e935b108f8f0d2(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb23b7f52de7db6e9a625fa8454752268536cb8ff8ba9c44811e4eb3a0387370(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fef1f643fb4b202b92a09208369c8ab1fde9ddab70fbe2ec7846f4fcd21d6503(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4dbca35e4914255e0279b1d61059956804d0f7250234053b0ee76a6384198570(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f91ab410767d141e4748e5e96f72e9a5ccd579262fc325deb4f474e64b17369a(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ab2dcbb20cd327f7a249c214f6cfc93f9e023fea8764cdb0dba2461b164c533d(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b83f77b13bf225d451aa245360aebfaece0685d635a9b435d657b957d2d8bdc0(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8718b471ff8e08b446d204932a62ced5c20dc254a0eb7a3d246a776fcd8f0e83(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28ca470645ae7106b593e02924e610dbf279c08694ac6f66651c214c74d412de(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    connection_events: typing.Sequence[builtins.str],
    connection_notification_arn: builtins.str,
    service_id: typing.Optional[builtins.str] = None,
    vpc_endpoint_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea81fa4c28a28130c40f42ef988e07f5a933e12360aec4c4ce8906f11408be8e(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd5babf517110e51ba6c2026a81d423f167d3ff443224ecb8ae9157591c6fc94(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__461502328f1915c382064a9f97e8339f106d85ad2e0bc2f2d6941c39fd0ebd29(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca5d3ce920eb5a5d00fec3e569160090961a27d8388605e0da686c9ec9967d80(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__854075224b2a1c5aaee62fd32ffce65442a53f3976b3271f37e670e2c26a8352(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6c4b48cfc16ca27f30c5478637f260bb601cdda20c27aa02b58ebb642f57eeb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e41c3ca58468397b88d0fe9b9af25af62cccc7a408eadc3db2286a9f27a7fdff(
    *,
    connection_events: typing.Sequence[builtins.str],
    connection_notification_arn: builtins.str,
    service_id: typing.Optional[builtins.str] = None,
    vpc_endpoint_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34ba69df521981275d9321266877bb15ffeaff485197a94710ae57c73b0cd2f1(
    *,
    service_name: builtins.str,
    vpc_id: builtins.str,
    policy_document: typing.Any = None,
    private_dns_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    vpc_endpoint_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bd65bb2d0beb1d62ef8b72a33a352ac48e00600bc2b025bdec06b82cf7cf57ee(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    acceptance_required: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    contributor_insights_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    gateway_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    network_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    payer_responsibility: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__957d0b13087a5a1c7afd830c8d67d8a66dda673f60c930be5db2f6796e21edf4(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ade08a9cff0bfa7cbf329c1fe21275bce925552ca1507ee915e5ed307657556(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f24d84605dd93d128eab36463b95fc34a65ac34595988f288ba091969d8c3e48(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a38f79e9d58e9d5ccde278abb390c63a399ad8469ef4c429447f8e973e86b1db(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92370ad93c8a0a0919c9746f7cdec6b56b2b1b55f53f9d2cbc0669e5b6091201(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__93061701b7bc363aae54280ccf83f94479c38567908d2c51597ad1ee58387d4d(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2babfa96e86ea450f85f7e83cc11905d68dc09b226c3e578bfcba308572f24b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9f265c29703b637af4ed1222cca0cdcd5ff13a4888b2a6771b0476aa3c6edb0(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    service_id: builtins.str,
    allowed_principals: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4af6194d274e73e0d84c9e28ad5f3f905ffa6eb3074c07ecee54c53724dc9e47(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a7d0bdf0df2c60d10ef1d8a9cb9da9138c3f9cc7ab38f59acb47fcf89c470ea(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cab72c441e664d891c2b30162073f27b3e88386b86be41a3880bcdcab431cefb(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ef9e1e30adb2a660166f4bf6fc1fca3b8169d82d5fac79c57597759e90d51b55(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6fa6b05f468834197f8ac5ad6fead69a294ceac2af65d381e83ad97a1f2cead8(
    *,
    service_id: builtins.str,
    allowed_principals: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0924bdc7dd965ab8320d62e573fa88bcec434cb586b2ba9e4f291616938c2120(
    *,
    acceptance_required: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    contributor_insights_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    gateway_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    network_load_balancer_arns: typing.Optional[typing.Sequence[builtins.str]] = None,
    payer_responsibility: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd545e7e637e4c1fe8133e31ecb56fe8e86ad6380825864b2456a3974ec7d612(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_id: builtins.str,
    internet_gateway_id: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e8c1b051e6949f327f5f887d473e4ed8fa7ab3d78dcbbcdd368720a3c3bdcdbb(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19cdd8410853a775601a72c0c56d426086a8c740a41193ffd27460252888cac7(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dca7e25f2ecac14ca4d5d0f2d4e239a679ed34b28c7d68b120c424ee4b6ea61a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02529bf6feaf9b8eb6e764e95564b1545a5df8516772795cada582a51faa964f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dbbf47daf665dafbdfd3b3091635738948b3269fd92d6b666d2553accf67aaeb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cecf6c938749e886ce2b690feb4051e950c34a1abd4598f60184e9796a4fc95(
    *,
    vpc_id: builtins.str,
    internet_gateway_id: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__283f16af40ac820cdbf7878504f69ab5dc33365aace0c2be45d7515bdf764711(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    peer_vpc_id: builtins.str,
    vpc_id: builtins.str,
    peer_owner_id: typing.Optional[builtins.str] = None,
    peer_region: typing.Optional[builtins.str] = None,
    peer_role_arn: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a4e53245dec00e8851e1dd600141942f7df1471ef19b4373e05dbb18043678f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9c2a28bdb588c1f2ffa285ff2171d5740e05fca3e7b58a3f9bad65c7a90ffce(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aedf6ce3d2578b154db98299bf7ffa383ed7aceac5c744e9111ab5523eb64f1a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82e22256c5137d1b0812e66eb90a5f2c67578576df13558b18ef25f37e65f5f2(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3caac93b7771994a093ab7ef496c12437be78c55567256f7d201c81b4c05ce83(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9208f42debbf50ce924fb422365716d6c4ad8cf43c1041d74ad9dde7a4c99287(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cdd72bcb19bc3cba191f4d943409326a497be999a3a4c30e5344ad41ca6f31d0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd0acc940ee7b00909bee13ea3571aaed833a11db1602f2c73923e56aaddfda7(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5424980a0758a93dfcbc06e12dba4559a33fc57d542bf705aca4fbc3aa6f52e(
    *,
    peer_vpc_id: builtins.str,
    vpc_id: builtins.str,
    peer_owner_id: typing.Optional[builtins.str] = None,
    peer_region: typing.Optional[builtins.str] = None,
    peer_role_arn: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4533ebc56b9b17a3cedf2eb9ed9b46cc1677da7d71a319f06e950a5e32c57b4f(
    *,
    cidr_block: typing.Optional[builtins.str] = None,
    enable_dns_hostnames: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    enable_dns_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    instance_tenancy: typing.Optional[builtins.str] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e77cb0020f820726a03bfb8968e16674c7c5924b0f133f50aeda1623f31d6d55(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    customer_gateway_id: builtins.str,
    type: builtins.str,
    static_routes_only: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_id: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
    vpn_tunnel_options_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVPNConnection.VpnTunnelOptionsSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c032f6cb3a85e604e1c909c281575f6045b37bc3b2687fd6f712fb70192837a2(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc1b950a80a4fe71844cc3fb3fef45a30e33bdcba45a7397c635c943176eeb91(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b8ee030670b1b9643fa4d07392b8ca16dfb2b4c74b9f2614b03645b72d453e91(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__59feaba339bd40609d7cfeabfd1d3a6faa58b8495f350550071b7ac9e9e5b7a3(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e6cd3e38d95994ecfc9ca7d55958632e80d3f4b2d30513ab106e3fe76821aacf(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__938f7fab03256c6dcde99c3812a0afcd1e1d67abbff79e50a09b2286bbae4251(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__863c644d46be7fb81e39a402d096afcdf597ce502577d6486a258bb4900ccdf9(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68e0671a952b233ef44cb4e18db3052fff5636ca696c56590e9879c95154ce05(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e5141022cbe7f67d8c3189c0b096230c58a40a82fd75e0a817bb5321c52e1a9(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVPNConnection.VpnTunnelOptionsSpecificationProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c11a91303ade674ac2062d6f836f1c6c8a5ffcd828e189ee16a639aed0741e2c(
    *,
    pre_shared_key: typing.Optional[builtins.str] = None,
    tunnel_inside_cidr: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af86adbb8c205a09b71896c35d8dac6b766cf096efd20c2deb4c2c01eea74408(
    *,
    customer_gateway_id: builtins.str,
    type: builtins.str,
    static_routes_only: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    transit_gateway_id: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
    vpn_tunnel_options_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVPNConnection.VpnTunnelOptionsSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62f5d72062803bba85ddfb772ace952f2d084839504c093614485b6ed47a1f4b(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    destination_cidr_block: builtins.str,
    vpn_connection_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__018cb671f4d662afcc429d96efa414f86b8478656300f96777beac1473bb097b(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3a5735370729504da37e9032e10e7dade7cf4b741b7b1030d7412ada526157ad(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__301b6c3d75b965dd9144974f533a6299f8a5031a16f3e6ce6d726cf0056f1fb8(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__94e27e66ecd12f654abae25e393a9e166f5a434c3c46f76396d88ae2e8d7a5b4(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8891e9566df17d3226ab7414fe88aeb135bee1fb42156b77ca3c05eb5e52e293(
    *,
    destination_cidr_block: builtins.str,
    vpn_connection_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30b37990cd28e78bbf86bb3095b8b6ccf2667a518f64b1c2703b84ca600ad12f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    type: builtins.str,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bec6f2401f76af768748e44f4b219c1c0e7bf274aea83c8308b9ba16a7f84088(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__77c3a3d9401386d2c855a95b876eca004e02fbae57178c1e633ed7e59d450922(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfd4a16cd09365bbdd1ecdf3f779a819d4708d295b3443dbabd82e77bf9624b1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__444b1fb958ac1a12c130cd92813cde4fd715d24f859e6b8bf7a1d1531f64e455(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46ee07e6f81ec8800a47be0059211244f3fe11360f85c7d3a0f0723ff984062b(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79bb5db1bdc49a09c4960a1b24d8cc88e36ee93d9fba7beeb6372b60511e1a29(
    *,
    type: builtins.str,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__72082dc868990f0a6bf65359c4e13c6bffbfb7a161dc63811a1cc4a97b34c8bc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    route_table_ids: typing.Sequence[builtins.str],
    vpn_gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76cbf30e0dbb3902340136a2f03dd9b928e14ef079cae574f42d97a1e9e4a161(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c75987cbb7bf572e6e3a39848f0b94c62c77e71999ea6386fc12aa417ebb3b7(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84456ae403f511ecc26fe921e1a4c16b07f068858c6c4ed0618385986e82c865(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d28a1ac9b80dd54e7f1024857eb164a6cb07540c423e8ef6ce2539574cc7c03(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4978b3e27b6b5b3acc1c3fd0c26b22bd9e1dfb57f459fb21bb4a137666cc80b9(
    *,
    route_table_ids: typing.Sequence[builtins.str],
    vpn_gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4d36b12d1ab3c67a3dfcd9bfed6cbbcb2f1267d23c43d3209213bf00969e5f91(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    application_domain: builtins.str,
    attachment_type: builtins.str,
    domain_certificate_arn: builtins.str,
    endpoint_domain_prefix: builtins.str,
    endpoint_type: builtins.str,
    verified_access_group_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    load_balancer_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    policy_document: typing.Optional[builtins.str] = None,
    policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__abb70fea7de6ecd9de5e606c92990b20776b67f68e61fe0266304d7bcb9ff072(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bc2a2c5e187d55f32f86bed24144fa2c14723e28c2c028062d6941f44ca9e89d(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b28061f28b3f28be486d48f7dc7fd621f3103258eb9e7885ff475e46e5fd902b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1d10e167e554b430eb1ac5650dc7e833d44fb08c080f0db7bddc1e8a7fc72cb1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efc1ee2a591d8925ff2f8ca9eaba761d65c8b57e365164d2a86e578e910f175f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff9d0e5773a8d9ea22993cc66220368ac095ea17382c558d7190b96a647f458f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e1c912930012351cff79ab0fb5325f42f80c3484801d0cbe19a20d7a19cd8f3a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__89c39e6200e18904b3557bcd57dab1d8a26e87af526f5462ad34ddbffada9d08(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d4d12173aa39d537b02fbd1df1f0478890f6c89c75db9f7940f5afee0f771734(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__01b015d4e05a67fecfe59a236985e3c9ad8b2b7791748dd8c5d032d1bf017a03(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e4b033be4b1684292884e782e482cc7e86bf5adf5cd06608d429f1c45141157(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__655685c756b38b8b8a61041c012546a0287e1cb6ebb9e768c9d8f820c1180e8e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d544f882cc7fa74d192a81ca201822cd80d9f91a6c0680be92961c818a6eaa64(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__102770719c6031007d664c25a6414989d2e114f24811888a51575fc6a9fbbea8(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7156f5bb188e847d9f05c0e3e60f09d93517831c58bbed0fe93cc2ca53a27c08(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessEndpoint.SseSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3d819c87bb8f385fc1e857a7fa5b0c4d1892fee609cc4cc3aa40264566a5ba4(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__748e5ad8bcd3de0f9d4460d24ba08621e5769f4aa625427a31af6f4cfad10c64(
    *,
    load_balancer_arn: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
    protocol: typing.Optional[builtins.str] = None,
    subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__87a3b1db27ee0d26aa10f209574558cadfa966a187d72396dc2453f49f105d43(
    *,
    network_interface_id: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
    protocol: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02c635a2da8a4b8f86f38bec4cdb7864386d5f2c0ddad83ce923502ececa7167(
    *,
    customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    kms_key_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a6b5fcbc7d5ca5da1405e117289abdd54dfab30dc79e867da0da32239d886ee5(
    *,
    application_domain: builtins.str,
    attachment_type: builtins.str,
    domain_certificate_arn: builtins.str,
    endpoint_domain_prefix: builtins.str,
    endpoint_type: builtins.str,
    verified_access_group_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    load_balancer_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.LoadBalancerOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    network_interface_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.NetworkInterfaceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    policy_document: typing.Optional[builtins.str] = None,
    policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    security_group_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessEndpoint.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__febc0dfd1bf5844b4356256e7c6467491409eb1cda95c95317e8e03b55be995c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    verified_access_instance_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    policy_document: typing.Optional[builtins.str] = None,
    policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessGroup.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dee012429baf2cb461e340b1cf429e6ca5f70012bb627476bfbf9d039199501f(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a4d2938c7ec5429f9c860a82a8eee6f48bb5770851dd45aad58d91ceef78e61(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd1957d8d821c3ab381fe2f7a8b1b797089f01c610d4cbdf2bb30c065780b321(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7aba4b12ab79b9b81cf832f871dca71142483f4f0d3602e13b86e5e1bb301acc(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ad42af95f5e36e38ec0b3430e344bd52f880a38113784068d9132df11825366c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8fdb63a3c9c468a3c2efe7f74eb56822b8ea9fd37530ce6c824319101a57d393(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca598abdce14557766e8bdb3540714b33b146846db4041f4bd06f01357aa26e6(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessGroup.SseSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96b483adf9d6f7282729e63f923c475bce48c71cf285f7937ba32321b69399db(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__986d725f46a507210471f6bdd732188014784f0fdd6b2784a4970b6d3eb8b1b6(
    *,
    customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    kms_key_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a227e52aaf71829a5bd6ac823e30ca68b617f093528775cb853d4dfd9a667597(
    *,
    verified_access_instance_id: builtins.str,
    description: typing.Optional[builtins.str] = None,
    policy_document: typing.Optional[builtins.str] = None,
    policy_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessGroup.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__210b67953502d567079f8663990436a4ba8d53414d251da116ccd8eac9951667(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: typing.Optional[builtins.str] = None,
    fips_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    logging_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessLogsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    verified_access_trust_provider_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    verified_access_trust_providers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c0271cf05a81cceaa3b29ac96c0cad6feacfc39a01972257604533b896429b7(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0310f5df079f4d94843fdb4879da8562ae3108d66ec4cd10201c900aff51f0f6(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ba3dd03cf8f2db417bb16a3849e48282d3bd41790a0db527717302f3459305f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__46f7e98a9ee27ebc4332a3a0b4bc5e72cf85aada2dafdbe68d3d16aafb3631ac(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4955f8f53f851348c8285cac4ecd1b039f966961bcff2cd543179160ada57973(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessLogsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__100282dc1aaba64acc97f9783bf1e1be20a97dfb87ea40204f93a334aab4f756(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3c8d28849cc9dc92ee550528a94d5da78121111bce48c647902e6af09fdfb537(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__27dd0a41155716b4183a01751d9d5f230565a6e03f23253780d8bf04c8b24e1f(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty]]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__44bffef7b929e685f0e0e13a13be464cdc14cc4672e87b469af3fda94556699c(
    *,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    log_group: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__54733b0f065eb2a9c0e450f9e84ab0fc1cfd0fcdcf1378adf014441333204f8f(
    *,
    delivery_stream: typing.Optional[builtins.str] = None,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dc970afb92be346ba67ba3fe83b5aae03c5555879c0974b909d72f4ff77e1cbd(
    *,
    bucket_name: typing.Optional[builtins.str] = None,
    bucket_owner: typing.Optional[builtins.str] = None,
    enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca37305754055968c478f1947f0a7d8dd1d7b0566a8cd16dba7110112d42866e(
    *,
    cloud_watch_logs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.CloudWatchLogsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    include_trust_context: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    kinesis_data_firehose: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.KinesisDataFirehoseProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    log_version: typing.Optional[builtins.str] = None,
    s3: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.S3Property, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa1b1a9d00743fb82589cb1d8f7514bfaa414568bff92a69bc361d83017bbf87(
    *,
    description: typing.Optional[builtins.str] = None,
    device_trust_provider_type: typing.Optional[builtins.str] = None,
    trust_provider_type: typing.Optional[builtins.str] = None,
    user_trust_provider_type: typing.Optional[builtins.str] = None,
    verified_access_trust_provider_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9a24ec455946fcefd05480c5a9ec8b48ab899be4d2ad63a1acb976abdf7df46(
    *,
    description: typing.Optional[builtins.str] = None,
    fips_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    logging_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessLogsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    verified_access_trust_provider_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    verified_access_trust_providers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessInstance.VerifiedAccessTrustProviderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7fe983b5e05e5227bb52a4924627b4c6164af2055ac21783dbe757c2b6acb27(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    policy_reference_name: builtins.str,
    trust_provider_type: builtins.str,
    description: typing.Optional[builtins.str] = None,
    device_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.DeviceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    device_trust_provider_type: typing.Optional[builtins.str] = None,
    oidc_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.OidcOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    user_trust_provider_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d88a304ffbbf17d299736418c1922495c74a433c9b30001e2bcbb69214df2f59(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f96a787f3339b7f6ca35766b655ece8f2f7b1c0c074bb60b12c38b5d98d97b07(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb2c31b98041aaf47d8cfe7a3c7ce8249f5ff0be19cc2c687c8cb1bccdfb16e1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45761c0ccd9af44abd6237ea9f2858300acdf7fa35301506907805ee92afe45e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5596e28580f200cae9ee9d17544f728da33d5f8b120e97e5f75a7bcf6bd883f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__58b5c20afb51f02a4dc38b9b3d77d6773ce2510a70f043f97eb9b86aba09fce7(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.DeviceOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__86233e326be8a89b76683cacdc12855026065941b80a6573d40ec5ed9c51e1a7(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3732e232bbcf8298bc1fd1eb5a3f0b56a229a30c2b1db74d6c78fcfc80e5e77(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.OidcOptionsProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__61dbb79cf6feff6860cc4e694ed7d715999903a77d202156b9297a946c1adfe5(
    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnVerifiedAccessTrustProvider.SseSpecificationProperty]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b72cb8ed7ba887a1a566023a64d8bacd231d393400f4c30c557d902f1216443(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4967d13842c9c8f34f254422ba9a304b8c052cdea0146ce880f1a5cc65ab27fb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff8d5f091c9e68a3470f9e83329b9ea9e8e9c3d69327e30f7c804de09801438f(
    *,
    public_signing_key_url: typing.Optional[builtins.str] = None,
    tenant_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c7104c0ccee8d56cc5467c88b16f90245f04363672ad962c4ba9a01b66966498(
    *,
    authorization_endpoint: typing.Optional[builtins.str] = None,
    client_id: typing.Optional[builtins.str] = None,
    client_secret: typing.Optional[builtins.str] = None,
    issuer: typing.Optional[builtins.str] = None,
    scope: typing.Optional[builtins.str] = None,
    token_endpoint: typing.Optional[builtins.str] = None,
    user_info_endpoint: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b6783e0e43d78c8311170a32417981320a95954dbab4be61dc06fd6f890dde1c(
    *,
    customer_managed_key_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    kms_key_arn: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a76a73a6fde22e9c9fa58fb20740e000e9153307f66b7f13cb4d7fe8bb6be7a9(
    *,
    policy_reference_name: builtins.str,
    trust_provider_type: builtins.str,
    description: typing.Optional[builtins.str] = None,
    device_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.DeviceOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    device_trust_provider_type: typing.Optional[builtins.str] = None,
    oidc_options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.OidcOptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    sse_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnVerifiedAccessTrustProvider.SseSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    user_trust_provider_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__915a70f35b9237e059cd8fc78c5da31e1d4f2476ed4857c7ac173e559447905e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    auto_enable_io: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iops: typing.Optional[jsii.Number] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    multi_attach_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
    size: typing.Optional[jsii.Number] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    throughput: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2a2f83998f9a1f05fc7aa51cad422fc8991c204c3bd4a1497c7ad336226ccfb(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f774e878be0007be0abcd6c15b4c68663fb4b630b89e8ca74b84808f2dc4266e(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d1b84d91c4e8cd76822b48ed0343301ddd2a721e24f40035f18674528e6a7b7(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fdc1847dc310b2a1577e5dcdebe88b86b9758cb785d226da14643575f9ed8bd8(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a0dab307ba7c618b3a2a8af0cf29a1e9133b8702661f57ee95de967a6735ab24(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__807a1d840cc3d255028247a06a6ef15c200d09e79136ebf2009053f8b69ffd1a(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a031a395aedeac6fb43372966648e605034195c39adf3a5eb5d79fca8a2e05eb(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e2e4bb0974e2a111c4cb4e3d395830b7cc54aeeb30dbb46934b3474e9b56460(
    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0ef1cb0e21c5581e1fbbd559f33ec33f532d3ab32f1d04856178952abecd54dd(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b612fe5742ad859f2f5b61d73e008fc633f66ed6eccf5d3ab41d6dc2403b7844(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__62fabf6e3c9fe7c72a6b24dfb7236158ddc7f0739372217b4cd7c02809a327cd(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2492a2a8e711d8a4ec13f5ac387221ec25b8844eb318d76f2f9913a44d0e80a1(
    value: typing.Optional[typing.List[_CfnTag_f6864754]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52b794f14acdf16af1459720ad364d41f271215d47cf0e4717dd83ce005e4b69(
    value: typing.Optional[jsii.Number],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45764f3b57b9177d923e13cf91fbc29ed9c80eeebc001d4bd7c1600d28437ee6(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f91e3af459fd3c08f3e864b943d726fa098088641452489ce64fb32280c6e8d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    instance_id: builtins.str,
    volume_id: builtins.str,
    device: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c3fecb972815426281f672313569cdcfa38b276801c82a6aad225ecc33f44424(
    inspector: _TreeInspector_488e0dd5,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb30c7c03599c59990efcdf751a9418ed9f6c6ca586614259701e1efb0f26a25(
    props: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dac7c5a8973cffe34d524c311d935f23aa495f0cd2b578e4f86ad9f0c407492c(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__beb3c2d5f9b7dbc507ec75d698c4aaa10e1a2d6c151eaaabd7b8983704434b1d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb607912a28c459177794348b3a0d3c1a5dec52861d12a3350f8cbd1748e4985(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6271dcebfee0c630e1316ce2182ab20ce3a7666c38f1a8e7d0c5d8226de8479f(
    *,
    instance_id: builtins.str,
    volume_id: builtins.str,
    device: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__df1f84bfc2d41a9f2d283d6a706150686c01c8f45a742c92af54cbee7bc75f3d(
    *,
    availability_zone: builtins.str,
    auto_enable_io: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    iops: typing.Optional[jsii.Number] = None,
    kms_key_id: typing.Optional[builtins.str] = None,
    multi_attach_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
    outpost_arn: typing.Optional[builtins.str] = None,
    size: typing.Optional[jsii.Number] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
    throughput: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6f8556471b9878ffc0a31155bd24890dd137dc2f25f5faa23ec8adbfb35154db(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    client_vpn_endpoint: typing.Optional[IClientVpnEndpoint] = None,
    cidr: builtins.str,
    description: typing.Optional[builtins.str] = None,
    group_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fc07ac4ea1a45fb240bfaf16763919c7856484bb210d9dea034d4beb7c00495b(
    *,
    cidr: builtins.str,
    description: typing.Optional[builtins.str] = None,
    group_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__70f178e990e98988f4f5a0c35f7e79848b474cc9f47c2cc007d2c2694316927d(
    *,
    cidr: builtins.str,
    description: typing.Optional[builtins.str] = None,
    group_id: typing.Optional[builtins.str] = None,
    client_vpn_endpoint: typing.Optional[IClientVpnEndpoint] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6321df916114580e1b10f3608ccf6ea302a3a8abe3ed6fe5a06f37024b167c26(
    *,
    endpoint_id: builtins.str,
    security_groups: typing.Sequence[ISecurityGroup],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__73f8593e2e6199f8ae542cff4cbe02f0be09fd9043b8072cbb652d5b05d44687(
    *,
    cidr: builtins.str,
    server_certificate_arn: builtins.str,
    authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
    client_certificate_arn: typing.Optional[builtins.str] = None,
    client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
    client_login_banner: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    logging: typing.Optional[builtins.bool] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
    port: typing.Optional[VpnPort] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    self_service_portal: typing.Optional[builtins.bool] = None,
    session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
    split_tunnel: typing.Optional[builtins.bool] = None,
    transport_protocol: typing.Optional[TransportProtocol] = None,
    user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8e89ba9082e1bc80500c526e8522c5a90e2a91bd17d985f5932611e0b60e10b3(
    *,
    cidr: builtins.str,
    server_certificate_arn: builtins.str,
    authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
    client_certificate_arn: typing.Optional[builtins.str] = None,
    client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
    client_login_banner: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    logging: typing.Optional[builtins.bool] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
    port: typing.Optional[VpnPort] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    self_service_portal: typing.Optional[builtins.bool] = None,
    session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
    split_tunnel: typing.Optional[builtins.bool] = None,
    transport_protocol: typing.Optional[TransportProtocol] = None,
    user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c072da507844f8a068ea56fa36968badfeea4273e8fd69c18fe5d1d26ef9a8e5(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    client_vpn_endpoint: typing.Optional[IClientVpnEndpoint] = None,
    cidr: builtins.str,
    target: ClientVpnRouteTarget,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__02f852bc1d595c3b969e64ca7c8edc426c0f6957269d65c35c984f995497d8ae(
    *,
    cidr: builtins.str,
    target: ClientVpnRouteTarget,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9aebb8dc3b9f2f386d57a9b72a9af25ca254b4d99a708cb292f073f21129172a(
    *,
    cidr: builtins.str,
    target: ClientVpnRouteTarget,
    description: typing.Optional[builtins.str] = None,
    client_vpn_endpoint: typing.Optional[IClientVpnEndpoint] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb562b03168df2ba61364ce7a57936d64dc7317de907fc9d7fb2c5843aac598c(
    subnet: ISubnet,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae62dcea9e6df35a85e3499917627b34f95268abe3a5a1afdbf25a382be28238(
    directory_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6bcf03d221545d954a7409f612a38519f9e0fdf2566a3537ed47f8df0d1a642c(
    saml_provider: _ISamlProvider_63f03582,
    self_service_saml_provider: typing.Optional[_ISamlProvider_63f03582] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e7eb6c53f66a5111d286ac86bf0932ad0ec7c97e10450d8210c36b0b50e38754(
    config: InitConfig,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6eafe1378ef68d49892c98ec2694c74a60615aea346240fcfa0fa07b14e6c879(
    *elements: InitElement,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bf8dcab27683c66ad2d91b1b6b94993856dc6d5b8727f690e4b99208c986bcfe(
    config_name: builtins.str,
    config: InitConfig,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f4517553431ffde7bf841015c186e708b91a97e3de37c86084362663f9c60296(
    config_set_name: builtins.str,
    config_names: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b4d3aa9f259ce8b05d6823c86e00c437a78f66039a8695636937742528967fdf(
    attached_resource: _CfnResource_9df397a6,
    *,
    instance_role: _IRole_235f5d8e,
    platform: OperatingSystemType,
    user_data: UserData,
    config_sets: typing.Optional[typing.Sequence[builtins.str]] = None,
    embed_fingerprint: typing.Optional[builtins.bool] = None,
    ignore_failures: typing.Optional[builtins.bool] = None,
    include_role: typing.Optional[builtins.bool] = None,
    include_url: typing.Optional[builtins.bool] = None,
    print_log: typing.Optional[builtins.bool] = None,
    signal_resource: typing.Optional[_CfnResource_9df397a6] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__851215aa7244914b1f8c755008192b40abf6bc0a46f4a061a8349af6c03f1177(
    *,
    cidr: AclCidr,
    rule_number: jsii.Number,
    traffic: AclTraffic,
    direction: typing.Optional[TrafficDirection] = None,
    network_acl_entry_name: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[Action] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a665123442e326bdbe182187f593792660e9abb39a89874372fb5e4111d663dc(
    *,
    configs: typing.Mapping[builtins.str, InitConfig],
    config_sets: typing.Mapping[builtins.str, typing.Sequence[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30190f3dbbe85d18aad8aa25317ab070d8cbb51a15a9e6f0388b0df3a464ad41(
    *,
    nat_subnets: typing.Sequence[PublicSubnet],
    private_subnets: typing.Sequence[PrivateSubnet],
    vpc: Vpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c3c97bf6fec5afd257e2e9b500690dc886a5091de9e05e08b9b9e1f9c625bf0a(
    *,
    from_port: jsii.Number,
    description: typing.Optional[builtins.str] = None,
    protocol: typing.Optional[builtins.str] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f9cb7eea3f313a061551c330a7ea339f496e026dbdc6a0984224bd0810bf1ebe(
    *,
    default_port: typing.Optional[Port] = None,
    peer: typing.Optional[IPeer] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d96a376ced2a799b1796cc6301f10d9c2070dbee68e3ab38d7bf98a6816d203a(
    *,
    ipv6_selected_cidr: builtins.str,
    subnet_count: jsii.Number,
    size_mask: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d06a3c480f0a868f3c69b22935c359322b1d9337591dc27bb141d518434f062(
    *,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4602c5be3c93ca5d255adf8aa3a652b8c7898310f96514ecd6fc09f7d5935370(
    *,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    volume_size: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__60130c664cd59ecac73373233b0978858b0e5c36c866ccdecbde22bbd7b8ef52(
    *,
    file_path: builtins.str,
    arguments: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e81eb717688593829094f61ef25c08b527f0c126ef12a4f4501f14ff1f5cc482(
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    iam_role: typing.Optional[_IRole_235f5d8e] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b3ea932697fa6e2a914a77fa81659cb98c5eed106039fb226a25f275e5820211(
    delivery_stream_arn: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79cf07d488e6d092fa437a996f1a5bdfa11272e368448e3cf26aafe3fdaba2a7(
    bucket: typing.Optional[_IBucket_42e086fd] = None,
    key_prefix: typing.Optional[builtins.str] = None,
    *,
    file_format: typing.Optional[FlowLogFileFormat] = None,
    hive_compatible_partitions: typing.Optional[builtins.bool] = None,
    per_hour_partition: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6de3e83d4f326681c20b1dcb1ee71d599559b05ce0028cfc61d592f89edbfbac(
    scope: _constructs_77d1e7e8.Construct,
    flow_log: FlowLog,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba6998f7072b44609280cd797e9230fb710a52e9376635e4a577c44a0389bdd6(
    *,
    log_destination_type: FlowLogDestinationType,
    delivery_stream_arn: typing.Optional[builtins.str] = None,
    destination_options: typing.Optional[typing.Union[DestinationOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    iam_role: typing.Optional[_IRole_235f5d8e] = None,
    key_prefix: typing.Optional[builtins.str] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    s3_bucket: typing.Optional[_IBucket_42e086fd] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a08c83d6120105afeb73ec881a412bb9097dd8643c26c0ee0ca8219a30bbd96(
    *,
    destination: typing.Optional[FlowLogDestination] = None,
    log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
    max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
    traffic_type: typing.Optional[FlowLogTrafficType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ca1b8e252416a0e606a3467258ca5d0833010dc7f9219ca1096813a8df530997(
    *,
    destination: typing.Optional[FlowLogDestination] = None,
    log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
    max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
    traffic_type: typing.Optional[FlowLogTrafficType] = None,
    resource_type: FlowLogResourceType,
    flow_log_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a488a320c16fc6456f63c84642c17f7a01175d0dbb8cac1022e6d3c42aa3daa7(
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76b2df28447c252d4e9f5ca77dd2f8f3b06b2858fda3051bddfa5c5834e0203a(
    subnet: ISubnet,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9d7627487ab93066cd2226a249164c563005466f84ef5b134d17cfd2575c2f8(
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4252d171c035a2a5753d511aae727f7536b3571e7a9a94317b77df10967bf1b7(
    id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71ca8111af1b31e7a6b4b9dafacd39309c7272133becbd480d415b8348234308(
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f5a45e85453138a588e72b7d2553bac08c85eaa74f42e9e84869c8cf792e354(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3d34300fa4a7621691fa63c06d20d8f88586f38f5c58560a2f25eed4efb38515(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b57cf38071e22f6aa0da293f72825a116e18760fc86d39f8d73ad02cd1f4945(
    *,
    az: builtins.str,
    gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d9788cc62897d6cd47b25ae688ddfe796bd0ff162f3bedfcb3b05a11efd685c1(
    *,
    service: IGatewayVpcEndpointService,
    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__be3935bf206eb9d190122970d9457b5ace891ba2d8356ccd2fe1959c201afa86(
    *,
    service: IGatewayVpcEndpointService,
    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cdec605761ae5397bea8594fe22514ce56475e36caaa69aa05dba865d23cad4a(
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6a8b65cfba9b4c22d0d25b80ef337d1fa4bcc5218fbcafc44f0550a54dea5089(
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb1a5b24515126d4cc13cb8fa4eb61ede7623f86bef6a5e2eaaa137acd37b531(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7a08c4179ae7228d55fc6cba81b9eb3e42e3720e4e0a43763e798855d612aece(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__722833841a526e50a0733e3c60dbe25042aa0bae5f690dcc002306163e17ce38(
    id: builtins.str,
    *,
    cidr: AclCidr,
    rule_number: jsii.Number,
    traffic: AclTraffic,
    direction: typing.Optional[TrafficDirection] = None,
    network_acl_entry_name: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[Action] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7958cf495af025dbfadcc5329145f18a4938eec2f36f8a9f026a0ccdd42c5aa2(
    peer: IPeer,
    connection: Port,
    description: typing.Optional[builtins.str] = None,
    remote_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b9d9655d432f001be225e968886d7511e46b49b3f5d7cfd940f4512ebbe5dec(
    peer: IPeer,
    connection: Port,
    description: typing.Optional[builtins.str] = None,
    remote_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__635c8e8063b1c2ee4ab6c10c91a7641b19ea96bc6b9ccb58b655d816854eb9a6(
    id: builtins.str,
    acl: INetworkAcl,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c1a65c8e09d2dd3f490d9ea3759672d994218e8ff9860d503c281ed504be84b(
    grantee: _IGrantable_71c4f5de,
    instances: typing.Optional[typing.Sequence[IInstance]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71d799af033c60cb531ed9dd09282b1f9abcd2d8b58a8565aae5ba1bb90cf16a(
    grantee: _IGrantable_71c4f5de,
    constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
    tag_key_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdec016a71973f32a7e119ad64acbdbaeec9f6c277881f45f4b57c30b8c8a29a(
    grantee: _IGrantable_71c4f5de,
    instances: typing.Optional[typing.Sequence[IInstance]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9572d33fd8dab37c25d4e29559ce658af3b0cbefb47b37ae545cd2e9dac34247(
    grantee: _IGrantable_71c4f5de,
    constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
    tag_key_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__19cdaa7bec0f733a863944b2be6c76392b1e518714158a913370b8de7c09e2e0(
    id: builtins.str,
    *,
    cidr: builtins.str,
    server_certificate_arn: builtins.str,
    authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
    client_certificate_arn: typing.Optional[builtins.str] = None,
    client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
    client_login_banner: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    logging: typing.Optional[builtins.bool] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
    port: typing.Optional[VpnPort] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    self_service_portal: typing.Optional[builtins.bool] = None,
    session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
    split_tunnel: typing.Optional[builtins.bool] = None,
    transport_protocol: typing.Optional[TransportProtocol] = None,
    user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0135e094843a52d426b6a129842d492990380d64cab0d48db48f4dbe0d9e575b(
    id: builtins.str,
    *,
    destination: typing.Optional[FlowLogDestination] = None,
    log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
    max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
    traffic_type: typing.Optional[FlowLogTrafficType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__23a57d5868b6e331624362856f06299729cc32be285aa37cc5efbef529bf3054(
    id: builtins.str,
    *,
    service: IGatewayVpcEndpointService,
    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a8399f0a6a7650e1c02d00770e21cad422b9760a1fdc24465cf54637106df2ac(
    id: builtins.str,
    *,
    service: IInterfaceVpcEndpointService,
    lookup_supported_azs: typing.Optional[builtins.bool] = None,
    open: typing.Optional[builtins.bool] = None,
    private_dns_enabled: typing.Optional[builtins.bool] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b660f36091ef3f17b29e55486b85b99103af4b45b1c0c12b38092a051a0b7782(
    id: builtins.str,
    *,
    ip: builtins.str,
    asn: typing.Optional[jsii.Number] = None,
    static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
    tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a2c1c58afbc5e81e1af61d18f3f4b2f840465db1e0e780c358e83b3a110de5ad(
    metric_name: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    color: typing.Optional[builtins.str] = None,
    dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_Duration_4839e8c3] = None,
    region: typing.Optional[builtins.str] = None,
    statistic: typing.Optional[builtins.str] = None,
    unit: typing.Optional[_Unit_61bc6f70] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__895498aa03e26d375242198136c0bb6545f960467ad94c90bc9418b7522a7bfc(
    *,
    cwd: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ignore_errors: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    test_cmd: typing.Optional[builtins.str] = None,
    wait_after_completion: typing.Optional[InitCommandWaitDuration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aa7b7f77fc9110826ec8df74528870f896a286b3793b09bec1879840a13d8200(
    duration: _Duration_4839e8c3,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f2fe8a9cd0b26d1fa0c137055d0db7f12f14f6ee9a3617696e66b4a4db761be8(
    elements: typing.Sequence[InitElement],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__237bb2e0a082e15538325c591128f1099768227eae00078b5ae7f19d9dc5c438(
    *elements: InitElement,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39a56bb260f932761d77b0140dc161ded874ce9256c33b195c00a72633e7613a(
    file_name: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__164f7ae4723652c2e5c3189a870d0dbd16f8bec14d0e807d648248a60dff8f47(
    target_file_name: builtins.str,
    path: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    deploy_time: typing.Optional[builtins.bool] = None,
    readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
    asset_hash: typing.Optional[builtins.str] = None,
    asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
    bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
    follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
    ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b888ad30ba14ff553b01013ce3c63033fc6ba7c5e38ed591fa853b73bcfd6f7c(
    target_file_name: builtins.str,
    asset: _Asset_ac2a7e61,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a7470c7a0aaf62b8c70ecc66688ff44ffba8d8346bf7ba2d28ce1fc200ca0219(
    target_file_name: builtins.str,
    source_file_name: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f988faf01115ca4996c275b3845c5944782257ad279b916362511c00db7af01d(
    file_name: builtins.str,
    obj: typing.Mapping[builtins.str, typing.Any],
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__331a134b436a492e3e40262ea88ee560c7a93d024631502fcff730bd2e24001a(
    file_name: builtins.str,
    bucket: _IBucket_42e086fd,
    key: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd20249bee2a42e1c6df6cd6c7ff87611924246dd9ceb3b13fa55b42744249c6(
    file_name: builtins.str,
    content: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1ae14eda61de45cd6b65d6dcd8e43beff37720eecc1008e5b0da1864c366857(
    file_name: builtins.str,
    url: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__33ac8fc20cb2d02dff9d497b10d5e0199a84409d271fc870831888220a16a472(
    file_name: builtins.str,
    target: builtins.str,
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9327bb8cfe7f6b516e904c6a9d60ffd97b10398f99361ba1f6b1b72c5b274c60(
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e55da79543d30150ac899cf419393b414293eb4ccadf4e7cfcd02bc3a6ff53f(
    group_name: builtins.str,
    group_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__038b5306a766a3f74d8ec7c0d18d563af893a3de0f27baa0451cdef5fbda37df(
    group_name: builtins.str,
    group_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed1c262b209111e032d161da94a1ff7dc7f47427f1ff40c9515754b0a8246bc6(
    type: builtins.str,
    versions: typing.Sequence[builtins.str],
    package_name: typing.Optional[builtins.str] = None,
    service_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48e8f1ab69dd7c8b52f329ce44af093d23dbb9262ef90ffcbf902fc740f3312d(
    package_name: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    version: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f339ea3f6248164c6e71705d6ffe8e12b4ad0dbfb8930a970293253ec79d8ff(
    location: builtins.str,
    *,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__913be26bbb3ca9a624b25935110fbfb15f03fbd9796883e032331c23089bc1c8(
    package_name: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    version: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c28cb8df7ec4dc1fc9206d5c20fa38a87e439c07fbab7318f5b7ddb144c7bccc(
    location: builtins.str,
    *,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a07707dc0fb1bf4e8e3d95b7727f81b9d8902e14aa0c0aba2524706eca1cb5c3(
    gem_name: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    version: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2a3727125d45f864366f97be2799e07039fb0b3c2b16c16dcf6995786c30d92(
    package_name: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    version: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96361796986e5070202d174d465472957234a071d81bb170369a1834103264ee(
    service_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__670f265ada6fe43ced07b09f682ad5ea1d9725b30f5c48bdc02351768c98388e(
    service_name: builtins.str,
    *,
    enabled: typing.Optional[builtins.bool] = None,
    ensure_running: typing.Optional[builtins.bool] = None,
    service_manager: typing.Optional[ServiceManager] = None,
    service_restart_handle: typing.Optional[InitServiceRestartHandle] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7573da52a8ea62c2b8aa64f8feb7a4a47ba65a4cac431430e05fdcee0b1ca060(
    service_name: builtins.str,
    *,
    command: builtins.str,
    after_network: typing.Optional[builtins.bool] = None,
    cwd: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    group: typing.Optional[builtins.str] = None,
    keep_running: typing.Optional[builtins.bool] = None,
    user: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__888d94950f15c9fd72ec8d35d2152d9acb230c63776b472d34136e20fa352507(
    *,
    enabled: typing.Optional[builtins.bool] = None,
    ensure_running: typing.Optional[builtins.bool] = None,
    service_manager: typing.Optional[ServiceManager] = None,
    service_restart_handle: typing.Optional[InitServiceRestartHandle] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__34231d9e8a364e89679bb8edf9b26534ebde41c89266b71ca3f232de4ebf58a5(
    target_directory: builtins.str,
    service_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28af50587b7c2068b2cb49dbac75ce38a6ffdaf070d2c430abde336ae451307d(
    target_directory: builtins.str,
    path: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    deploy_time: typing.Optional[builtins.bool] = None,
    readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
    asset_hash: typing.Optional[builtins.str] = None,
    asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
    bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
    follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
    ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b63a5ea7edeb5864739aae02a3d234ecb2a030c9f682594007c315631d06df07(
    target_directory: builtins.str,
    asset: _Asset_ac2a7e61,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1227483406e9a8b520fcc1607f7d7a112bf28c2d58603119c9e1086fe1e94dc(
    target_directory: builtins.str,
    owner: builtins.str,
    repo: builtins.str,
    ref_spec: typing.Optional[builtins.str] = None,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d57fbeaaaf4f2e9f871791185f997d8e6be218eb5d477a01677ab6512ee819ed(
    target_directory: builtins.str,
    bucket: _IBucket_42e086fd,
    key: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b751c7df3427bb50b6bbc41011ecf565eba0ea4785bf1192150991e661feb5c8(
    target_directory: builtins.str,
    url: builtins.str,
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c945323fe384c489cabde7df1d5d48da0402722153563ada43b0794dde492e70(
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e09968a4eba0339641c1769cf843d1960c52bd49baad08990ce9250575de43fe(
    user_name: builtins.str,
    *,
    groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    home_dir: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c27581c265d934daabe647b3a61428311285c1cd380571a1aa0dce63866c0dc9(
    user_name: builtins.str,
    *,
    groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    home_dir: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a0db662f4ed021da7805cde424c100768b198b77d6d6fc05d4a575fa7c7cff5f(
    *,
    groups: typing.Optional[typing.Sequence[builtins.str]] = None,
    home_dir: typing.Optional[builtins.str] = None,
    user_id: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5fdf31f5ae2497c7efcb56df558011698f38dc19cff28ca7a78a08a6d0ecc8e1(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    instance_type: InstanceType,
    machine_image: IMachineImage,
    vpc: IVpc,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    associate_public_ip_address: typing.Optional[builtins.bool] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    detailed_monitoring: typing.Optional[builtins.bool] = None,
    init: typing.Optional[CloudFormationInit] = None,
    init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    instance_name: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    key_pair: typing.Optional[IKeyPair] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    propagate_tags_to_volume_on_creation: typing.Optional[builtins.bool] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    resource_signal_timeout: typing.Optional[_Duration_4839e8c3] = None,
    role: typing.Optional[_IRole_235f5d8e] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    source_dest_check: typing.Optional[builtins.bool] = None,
    ssm_session_permissions: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    user_data_causes_replacement: typing.Optional[builtins.bool] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4f65a4eef2e405cd6738f4385dbe842a34ca38633b5632ab1201159a686980f5(
    security_group: ISecurityGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__515ae0d6edde8aae452bc3424eb0155e73288a314bf836395c6ce27e4194efa9(
    statement: _PolicyStatement_0fe33853,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82601f36068811ad664f607ef04191e661dad31e73a2a8f4f2c40217ffa18b3d(
    *commands: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2d4dc63c6e6ee3ddc68d5dd204d8ac5ef1f1dec37a7b84d636225df1c2f17d22(
    *,
    instance_type: InstanceType,
    machine_image: IMachineImage,
    vpc: IVpc,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    associate_public_ip_address: typing.Optional[builtins.bool] = None,
    availability_zone: typing.Optional[builtins.str] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    detailed_monitoring: typing.Optional[builtins.bool] = None,
    init: typing.Optional[CloudFormationInit] = None,
    init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    instance_name: typing.Optional[builtins.str] = None,
    key_name: typing.Optional[builtins.str] = None,
    key_pair: typing.Optional[IKeyPair] = None,
    private_ip_address: typing.Optional[builtins.str] = None,
    propagate_tags_to_volume_on_creation: typing.Optional[builtins.bool] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    resource_signal_timeout: typing.Optional[_Duration_4839e8c3] = None,
    role: typing.Optional[_IRole_235f5d8e] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    source_dest_check: typing.Optional[builtins.bool] = None,
    ssm_session_permissions: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    user_data_causes_replacement: typing.Optional[builtins.bool] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ea080e9a48a9cd3f51ab887978d6f84898a3e75d15344d8c22ea42bcbad6fc8e(
    node: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4774943551492528ef831ac6f6b59622fcebed6ac26f559cada819b1ecb0de66(
    node: _constructs_77d1e7e8.IConstruct,
    message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9326e8778e870d6503548ff3c5ed500440af6b908992d24dc8f76fa89771555(
    *,
    suppress_launch_template_warning: typing.Optional[builtins.bool] = None,
    suppress_warnings: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f9e12e553c32475e068e0d7318afcf27197468eae438a6b5020d7d6a0231705f(
    instance_type_identifier: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__97857b0f234071f13c18c9a44e7361ba42c63c7f58a30dde519a60f470c51b66(
    instance_class: InstanceClass,
    instance_size: InstanceSize,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__88f762204486759e1d4b8675273e25b3521a634edd036f75323d5584453cccf1(
    other: InstanceType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__67e7c8a745d0e9f6bf5d01dd69a00a15a09e2b5a0246690fad6ba8759c33a0e4(
    *,
    port: jsii.Number,
    vpc_endpoint_id: builtins.str,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3c5ecdce361b18ac8c903c131db56fe0de6c60b272b32768f92c0f0eaf6cccde(
    name: builtins.str,
    prefix: typing.Optional[builtins.str] = None,
    port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a6dd0208e338cbe286ecaa3bcf5f95a5f0a0c1e1b3565ca6de058b5fbe2bbdf(
    *,
    service: IInterfaceVpcEndpointService,
    lookup_supported_azs: typing.Optional[builtins.bool] = None,
    open: typing.Optional[builtins.bool] = None,
    private_dns_enabled: typing.Optional[builtins.bool] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6606ba3de030c44ce43dee44afe64adc59231bfc542799d1354e0732a309b2f0(
    *,
    service: IInterfaceVpcEndpointService,
    lookup_supported_azs: typing.Optional[builtins.bool] = None,
    open: typing.Optional[builtins.bool] = None,
    private_dns_enabled: typing.Optional[builtins.bool] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d463a2f9183f02e32ca03beb1752df250c2fb2c8b32f6f92dcc160804407c401(
    name: builtins.str,
    port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__712e8cdff0857893172d9de86affb30950183e037ef537789198de8ca49f9d41(
    cidr_block: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__723c12f80f8f69703f74949dec0a4305b19d6d27efff9d36830815d8e604283c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    format: typing.Optional[KeyPairFormat] = None,
    key_pair_name: typing.Optional[builtins.str] = None,
    public_key_material: typing.Optional[builtins.str] = None,
    type: typing.Optional[KeyPairType] = None,
    account: typing.Optional[builtins.str] = None,
    environment_from_arn: typing.Optional[builtins.str] = None,
    physical_name: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12d377269b610c395f1583e904a11636e952288b5e3f85a3cc1d865eb21f7715(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    key_pair_name: builtins.str,
    type: typing.Optional[KeyPairType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7bcad8d69b7ac63eda9832fb42b2e78a5f5570d5ccd5ac181f25d55202b6f74c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    key_pair_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c0b1d2207b185c203475dcfffe01485ff1d6dd460f5c0308f88afbd59667178(
    *,
    key_pair_name: builtins.str,
    type: typing.Optional[KeyPairType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7af23eb9509f044383945f68d46a72f0c94f0542177c255d3d31b42f5e9aa98c(
    *,
    account: typing.Optional[builtins.str] = None,
    environment_from_arn: typing.Optional[builtins.str] = None,
    physical_name: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    format: typing.Optional[KeyPairFormat] = None,
    key_pair_name: typing.Optional[builtins.str] = None,
    public_key_material: typing.Optional[builtins.str] = None,
    type: typing.Optional[KeyPairType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__544aef11081ec87047935491f75a3d5bc9d5075de77f96969bd2ffd1a0d78cc9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    associate_public_ip_address: typing.Optional[builtins.bool] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    cpu_credits: typing.Optional[CpuCredits] = None,
    detailed_monitoring: typing.Optional[builtins.bool] = None,
    disable_api_termination: typing.Optional[builtins.bool] = None,
    ebs_optimized: typing.Optional[builtins.bool] = None,
    hibernation_configured: typing.Optional[builtins.bool] = None,
    http_endpoint: typing.Optional[builtins.bool] = None,
    http_protocol_ipv6: typing.Optional[builtins.bool] = None,
    http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
    http_tokens: typing.Optional[LaunchTemplateHttpTokens] = None,
    instance_initiated_shutdown_behavior: typing.Optional[InstanceInitiatedShutdownBehavior] = None,
    instance_metadata_tags: typing.Optional[builtins.bool] = None,
    instance_profile: typing.Optional[_IInstanceProfile_10d5ce2c] = None,
    instance_type: typing.Optional[InstanceType] = None,
    key_name: typing.Optional[builtins.str] = None,
    key_pair: typing.Optional[IKeyPair] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
    machine_image: typing.Optional[IMachineImage] = None,
    nitro_enclave_enabled: typing.Optional[builtins.bool] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    role: typing.Optional[_IRole_235f5d8e] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    spot_options: typing.Optional[typing.Union[LaunchTemplateSpotOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c5bafc86e1cbb0e73c75092f8c58aca75ee08a032f755bf4acdadd68719d2e2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    launch_template_id: typing.Optional[builtins.str] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
    version_number: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9dd55f9f3b4519a893a859b46b35d0cbfb7aef6ebf26d57097c50fb4b9e2f353(
    security_group: ISecurityGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__59e32b8d80664a9fec0a3a5774b331fef386ee6f11bdc1bdbd15a956dae7d41d(
    *,
    launch_template_id: typing.Optional[builtins.str] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
    version_number: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2ebb1bf0fbb2f9e894169a610cd9fb7cc3f827d34d3a10351bd2f5174d9b3ae(
    *,
    associate_public_ip_address: typing.Optional[builtins.bool] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    cpu_credits: typing.Optional[CpuCredits] = None,
    detailed_monitoring: typing.Optional[builtins.bool] = None,
    disable_api_termination: typing.Optional[builtins.bool] = None,
    ebs_optimized: typing.Optional[builtins.bool] = None,
    hibernation_configured: typing.Optional[builtins.bool] = None,
    http_endpoint: typing.Optional[builtins.bool] = None,
    http_protocol_ipv6: typing.Optional[builtins.bool] = None,
    http_put_response_hop_limit: typing.Optional[jsii.Number] = None,
    http_tokens: typing.Optional[LaunchTemplateHttpTokens] = None,
    instance_initiated_shutdown_behavior: typing.Optional[InstanceInitiatedShutdownBehavior] = None,
    instance_metadata_tags: typing.Optional[builtins.bool] = None,
    instance_profile: typing.Optional[_IInstanceProfile_10d5ce2c] = None,
    instance_type: typing.Optional[InstanceType] = None,
    key_name: typing.Optional[builtins.str] = None,
    key_pair: typing.Optional[IKeyPair] = None,
    launch_template_name: typing.Optional[builtins.str] = None,
    machine_image: typing.Optional[IMachineImage] = None,
    nitro_enclave_enabled: typing.Optional[builtins.bool] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    role: typing.Optional[_IRole_235f5d8e] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    spot_options: typing.Optional[typing.Union[LaunchTemplateSpotOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5b55557b3575acd995d431b2ff6c8e2de0b98c65fba692635404794b841a612(
    node: _constructs_77d1e7e8.IConstruct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4640c020d65b4f4b05a42f3460ae9f0e3e18831e06ee60bc381a819010d705df(
    node: _constructs_77d1e7e8.IConstruct,
    message: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__461147557db2c4a085df02a1282204cc06509d5da8725adad11f3088fa4028c4(
    *,
    suppress_warnings: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a206647f8fdf80ee3d33b9394f5f273e82fa737f25e6e0d66c3a66fea6392403(
    *,
    block_duration: typing.Optional[_Duration_4839e8c3] = None,
    interruption_behavior: typing.Optional[SpotInstanceInterruption] = None,
    max_price: typing.Optional[jsii.Number] = None,
    request_type: typing.Optional[SpotRequestType] = None,
    valid_until: typing.Optional[_Expiration_059d47d0] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2127959dc053a2a795f9980d0ae63fe2060820b5ef07942b1a760aea504d4441(
    *,
    shebang: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__adb9aead901a9e42e17ecf53f0a66db93e64d4cc2e633a62de1a847f4c40aa01(
    *,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1c5c6c6cc89dffe7c8eddee547516c93284e5aac407878167afdf814ec7d9ade(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__116b2796c8db85d0aa8841c90870e7987ae492826d4ef5cab5a84cc6d0d154fb(
    format_string: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53a4a0b5f512af6dba8bc863e21b62304942117a36741bb04e639515b3195296(
    field: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__866a74bec8e14dd27073a82d4ff7b25ab450e0eff08b7026d084319984dfb12c(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9c44b2bd75c4714250889165d6fd2d06ab6a906b90c817320a7c5f526dcbfc2f(
    *,
    name: builtins.str,
    filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
    owners: typing.Optional[typing.Sequence[builtins.str]] = None,
    user_data: typing.Optional[UserData] = None,
    windows: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__677afd5ea9b4639913a489ab67346107c0d290e015be12483e980d3a19e33a6e(
    parameter_name: builtins.str,
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    os: typing.Optional[OperatingSystemType] = None,
    parameter_version: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d714de85d2e270ff2ba41661578c069d4eb1590eb5a816cd8ad1800ea2f837db(
    ami_map: typing.Mapping[builtins.str, builtins.str],
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__392190b85391a62926181097d2a921287a636c9c89ceeb2eb0894b5401830373(
    ami_map: typing.Mapping[builtins.str, builtins.str],
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0340fbf48f206279d16bd5e5e0956522ca9a19ba8d39aa2efcc7d06b4f130f7c(
    version: WindowsVersion,
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e832dd82a3ef447ebf9a639dc9d6983793ce7321287fb2370dbed898b67d02a(
    parameter_name: builtins.str,
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    os: typing.Optional[OperatingSystemType] = None,
    parameter_version: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7f17ef82ffed569e1d3eda15e99a047a5e9d8b0481590a53a25125d7f1fd7b79(
    *,
    image_id: builtins.str,
    os_type: OperatingSystemType,
    user_data: UserData,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4bcf5944bbf508c594d36bed8323ce62fc0d344d2e371da577833926eaa6822a(
    user_data: UserData,
    content_type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aab871ef93c0eb481ccb98fb7b5dd3fcea8e991b8366d72ad818b3c7d9f946c5(
    *,
    content_type: builtins.str,
    body: typing.Optional[builtins.str] = None,
    transfer_encoding: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a6cbd65538d4ad6bc35a85d0e1a054fa3cc215fdb97e33980478405a543ba7f(
    *,
    parts_separator: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2c1639fe59f604f4ab481f24912927ecf8af3c8a8827e677c9cac8d8b679f6b8(
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    version: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__addd8acc808c4965634311e54a7ffc0e3ebe29f2170d0d62750af3ad0b8f0a25(
    *,
    eip_allocation_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d7c7c717447859e1ccc181bc97f7752cc3f7fa7afaee4c3a4266eeac32c08643(
    *,
    instance_type: InstanceType,
    default_allowed_traffic: typing.Optional[NatTrafficDirection] = None,
    key_name: typing.Optional[builtins.str] = None,
    key_pair: typing.Optional[IKeyPair] = None,
    machine_image: typing.Optional[IMachineImage] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9e0f554709187c5ab170b32fa16ce08a52f06ecc68057cedcda4b7556149eea7(
    subnet: PrivateSubnet,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdf72e51c58e65bab33357b7df12d3ce802f1165c4dc64415bfac7ead4059eb0(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    network_acl_name: typing.Optional[builtins.str] = None,
    subnet_selection: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00fedeea0964c8a6bd2508f4ea6c217eb7a85085826373032f5190381821e799(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    network_acl_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__16785fa2c2b7254eaadd33cae07af702c325134c6581e041b66db73afae0629c(
    id: builtins.str,
    *,
    cidr: AclCidr,
    rule_number: jsii.Number,
    traffic: AclTraffic,
    direction: typing.Optional[TrafficDirection] = None,
    network_acl_entry_name: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[Action] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__757295a20459bdecbba45d5952a6bfab627e0a3218daec9e567df784604310cb(
    id: builtins.str,
    *,
    availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
    one_per_az: typing.Optional[builtins.bool] = None,
    subnet_filters: typing.Optional[typing.Sequence[SubnetFilter]] = None,
    subnet_group_name: typing.Optional[builtins.str] = None,
    subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
    subnet_type: typing.Optional[SubnetType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__36eccb106dd699342caabff87b4a9c8ae3591d6fd2af3021ab67f3dd055a58fb(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_acl: INetworkAcl,
    cidr: AclCidr,
    rule_number: jsii.Number,
    traffic: AclTraffic,
    direction: typing.Optional[TrafficDirection] = None,
    network_acl_entry_name: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[Action] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25285d8c5e40053fd948514da7a4ec2655e352c65cdcfbd382401943a4e35f21(
    *,
    cidr: AclCidr,
    rule_number: jsii.Number,
    traffic: AclTraffic,
    direction: typing.Optional[TrafficDirection] = None,
    network_acl_entry_name: typing.Optional[builtins.str] = None,
    rule_action: typing.Optional[Action] = None,
    network_acl: INetworkAcl,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__918b07b3c8f8cedc0cf766224969cc032fd164624c47a16176237186526566b1(
    *,
    vpc: IVpc,
    network_acl_name: typing.Optional[builtins.str] = None,
    subnet_selection: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__210a053f19d643e5f27f8152f0350703ea14905e76edde6bbfe73c476b9806fc(
    cidr_ip: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fe52d92bdafabcc16b1d7177b08a56f9e8058882c6924f341f0afe19dc53d040(
    cidr_ip: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ba7a76a669f261e0d00aaa251049148bd3ec9e49ef5d2263d637ddc7a07cf97e(
    prefix_list_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c50e745d8c4b7cc541db411d4fbaf133ad97d93fd8e648131c3e0c6bbad459a9(
    security_group_id: builtins.str,
    source_security_group_owner_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__427650d4bb55511bd9980d9c08a92379b4dacfbed10cb8f3fb827060e435ce4c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    partitions: typing.Optional[jsii.Number] = None,
    placement_group_name: typing.Optional[builtins.str] = None,
    spread_level: typing.Optional[PlacementGroupSpreadLevel] = None,
    strategy: typing.Optional[PlacementGroupStrategy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__13fa82f0bf97dfead8eec23b1f277a7e4319f0ed1adf710d4e722997c70ea0a5(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    placement_group_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bef176ff3d4f0b995f951b64f05655e76cc9c2bb772b196cbcc2f473ff46aadf(
    *,
    partitions: typing.Optional[jsii.Number] = None,
    placement_group_name: typing.Optional[builtins.str] = None,
    spread_level: typing.Optional[PlacementGroupSpreadLevel] = None,
    strategy: typing.Optional[PlacementGroupStrategy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__95b8dff2f4acc488f9cf50690ead7aaf9670da71be27099aa10e23d23920cad3(
    type: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8bb7512bf9d9583c10357d7ba3b7e954eb11d618b5e5fdb0d4d6efde8527250b(
    type: jsii.Number,
    code: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ed27477a26261dedd74ff51476afe2182a291e66de5954640b7e4d3a5721ef5(
    port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50936912c584cfa2a36269676fc55b98084d9ffb187095c90134c875fc629016(
    start_port: jsii.Number,
    end_port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6365151a22448259d687ae93919fac9d4a047edc2e1de37a48ed7cbf767aee4e(
    port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cea2c8ec112e0e1ddbd93b3d5076d84863d736e67dbee23440f816fa4b3e4ed4(
    start_port: jsii.Number,
    end_port: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f53682a2161eb5a4099c7690d0c7c734a1709dcaa9d6100123241e4bc281121(
    *,
    protocol: Protocol,
    string_representation: builtins.str,
    from_port: typing.Optional[jsii.Number] = None,
    to_port: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a8acc7e3b44d925ae96c4cd41872cf18233bdd11aba643610749ed9a484c5456(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    address_family: typing.Optional[AddressFamily] = None,
    entries: typing.Optional[typing.Sequence[typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    prefix_list_name: typing.Optional[builtins.str] = None,
    max_entries: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__11d084123507c2ab32a82e79ad64d9ff7d0962d3562cc06f04b8e900b3c6622b(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    prefix_list_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7cc34528909d71054422fc4b6e3439757c430d31f6f33a0af82b4c5b61e57e19(
    *,
    max_entries: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__442eb253076fc719267daf436fd1c12e98d31f5ec1af012b1a86fe3e46bd32aa(
    *,
    max_entries: typing.Optional[jsii.Number] = None,
    address_family: typing.Optional[AddressFamily] = None,
    entries: typing.Optional[typing.Sequence[typing.Union[CfnPrefixList.EntryProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
    prefix_list_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb9c21f15b378acd78737933455e65f7bb8b078652a7ac4ee6c1295016709aab(
    *,
    availability_zone: builtins.str,
    configuration: typing.Union[SubnetConfiguration, typing.Dict[builtins.str, typing.Any]],
    subnet_construct_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae85933c688e38a0dd9faa69a685488b55c8c19f918eabcacbd33c964c7bb468(
    parameter_name: builtins.str,
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    os: typing.Optional[OperatingSystemType] = None,
    parameter_version: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d20c701794e8ce600958b0084cd7254773f41a44aeda9ef5a9b369a5688d8019(
    _: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c97e7361447937a3ff7e70939dab0e82823557a4104f364486155f47ebcb9f5d(
    *,
    id: builtins.str,
    scope: ISecurityGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a525c7bfcc50f5d3a14f2363920f8474172327e7f9e8077799beb5fe2b32ea9f(
    *,
    file_format: typing.Optional[FlowLogFileFormat] = None,
    hive_compatible_partitions: typing.Optional[builtins.bool] = None,
    per_hour_partition: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__122958e3ae9e747726b547e8fdf1e540eb62b7085289c54d5c2b8fb6f13b2e3b(
    *,
    bucket: _IBucket_42e086fd,
    bucket_key: builtins.str,
    local_file: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__316108b6f1bf79b7e133269b99dee1a1a6a63cd0fe7b2ee4fc28ee2cf4ecc838(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    disable_inline_rules: typing.Optional[builtins.bool] = None,
    security_group_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__268af46e9b96e4963a9f2edc9cdca4f851f7ffad8efe5094fca1c65650100020(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    security_group_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38fa12ff9b16d1c8aab7f5c824213d7c1405eb244c7b2e0b25fc8b85d015a674(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    security_group_name: builtins.str,
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a078d45d43fdc6c29660bfbfdddf1bc2bd2b473230637a5526efa3841492963b(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    security_group_id: builtins.str,
    *,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    mutable: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__240ff3afc3b80af7aa57f8b5c2eff20d2f7af102addb8cf282ca2922f6ceb71f(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5c1db93dd7916ef933c13786d55d666b796d56418454500ce1225cb4d24f9c39(
    peer: IPeer,
    connection: Port,
    description: typing.Optional[builtins.str] = None,
    remote_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00557fc963b656805c2728b899d2a52811fe0eb30b79019e9e64bae9a39d0b86(
    peer: IPeer,
    connection: Port,
    description: typing.Optional[builtins.str] = None,
    remote_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9f9ad9749c7ef65867bc96b83aeacb3340670b7f57e4d710e42938a9151be29b(
    peer: IPeer,
    connection: Port,
    from_to: builtins.str,
    remote_rule: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d865607edfe09cbfe02f00518db09c521f9beeb5a40df2759334573b346f6a5a(
    *,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    mutable: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e55e0c52b51f92e83b1f8d6b7a5b22268d0369a14dab808b8f2f5f233e5b622(
    *,
    vpc: IVpc,
    allow_all_ipv6_outbound: typing.Optional[builtins.bool] = None,
    allow_all_outbound: typing.Optional[builtins.bool] = None,
    description: typing.Optional[builtins.str] = None,
    disable_inline_rules: typing.Optional[builtins.bool] = None,
    security_group_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__238a040275c82fe5911f2f1fd16a54d47e5937007b9647e86fefb63d03ed2300(
    *,
    availability_zones: typing.Sequence[builtins.str],
    has_public: builtins.bool,
    internet_connectivity_established: _constructs_77d1e7e8.IDependable,
    subnet_ids: typing.Sequence[builtins.str],
    subnets: typing.Sequence[ISubnet],
    is_pending_lookup: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a03f16dc6f5eb3eb6f69587f84001af20bc314a1c46a530aa5fb21da814be237(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    os: typing.Optional[OperatingSystemType] = None,
    parameter_version: typing.Optional[builtins.str] = None,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96072781b517bff13ac37560a4395f3f40d7b0ddea760cef61d9cf1cadd71151(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd74cec2b1d008b5efda354bf45e7106f5e4cc40bdeb4b483518f394bbc85818(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__686b32c9bead2f02f09e3359b02a5598c800bd8b62c5ea3d65e96c536ba974b2(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    subnet_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__68f9347923f1a25d2e9a24cbb80147f5a06b7a1b2d7da6fa137314a0dd5dd1c8(
    x: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec97f6f4a7083cd7c7886bd11d04e68a8da20aebc0d822db375888865588961f(
    gateway_id: builtins.str,
    gateway_attachment: _constructs_77d1e7e8.IDependable,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__683798bf23eef11df854e359c1532c285ed30544a6a4250fd2ffd6453c7661ab(
    nat_gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f8943f73ff6d17253f380b241cd0e184164b63a7258c7e4f2916266fe31fd6d5(
    gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__db7827d176dd32691ebb47dcfd1696462acd0dc0cf71a27c9a86164bddc9167a(
    gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ee90202f245f7f07ed5e535b7601bd31b62277991dd549319721b802a04128ee(
    nat_gateway_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__143de5737ac438372990371c031b759c0661edce7c56870abee6bae588471330(
    id: builtins.str,
    *,
    router_id: builtins.str,
    router_type: RouterType,
    destination_cidr_block: typing.Optional[builtins.str] = None,
    destination_ipv6_cidr_block: typing.Optional[builtins.str] = None,
    enables_internet_connectivity: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0d81feca462ace797ec97844cac189b9e3be40d625f8d6197163463755d73c02(
    id: builtins.str,
    network_acl: INetworkAcl,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f05cd73c1131d6a52fa73b365bc4192bdab3617a60af5aabdd9f57e9c5f3d966(
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__baa3ee59a393e7b31ebd9fb93534d193f13157ae242ba82fee91bdb0942fc507(
    *,
    name: builtins.str,
    subnet_type: SubnetType,
    cidr_mask: typing.Optional[jsii.Number] = None,
    ipv6_assign_address_on_creation: typing.Optional[builtins.bool] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
    reserved: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__38a0cc1a76167da2a235b0ca0b3ba3ca0a87e0efbda2debefac713e7a6c255ab(
    availability_zones: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__69817919d55fddaff58315445955b1b04b31a7f1747a977f7574982392cb8522(
    mask: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dd66e1d5763d32bc4d66828de712617e6b80071fc6c692fb79248a7fcc0fc64e(
    cidrs: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf740d57d9f14a6f82616f01d138bbcde7a61f1bcf4e42d9a86aa45df2b10e3f(
    subnet_ids: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__030671c7b435b5214882053b1def40a66979057219ca4d8b8ddf624772d7835e(
    ipv4addrs: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f87db5a7078178bd2ac961cf25c46aeea132e2b3aa4a72691a64058ac3a6a0a(
    _subnets: typing.Sequence[ISubnet],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b35738458ba5f72eb4c1356a32b03d81940b1f9303a0725fa8ec4903241eb6a(
    *,
    allocated_subnets: typing.Sequence[typing.Union[AllocatedSubnet, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__338ce06855fa4f764a7a3f24d490fe607a06dc37057a15554cef0543f2542c5d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    network_acl: INetworkAcl,
    subnet: ISubnet,
    subnet_network_acl_association_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9af4ad14510b112cde9defbcec82c0dde1def317501d84187a374149eb7699da(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    subnet_network_acl_association_association_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53d927301a63c79d241c9915400b7d48edcdb0f410ad38d20c44bc9e6cf5f0e9(
    *,
    network_acl: INetworkAcl,
    subnet: ISubnet,
    subnet_network_acl_association_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__63f433ea25e21dd7ee82ea9baf14e6a2200b884cccc4bc9ff2d6e0f12ca82f54(
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b4d4eba0670903dc365107b85eb99d41b1f814f9c8eed60e7014fd64063539e4(
    *,
    availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
    one_per_az: typing.Optional[builtins.bool] = None,
    subnet_filters: typing.Optional[typing.Sequence[SubnetFilter]] = None,
    subnet_group_name: typing.Optional[builtins.str] = None,
    subnets: typing.Optional[typing.Sequence[ISubnet]] = None,
    subnet_type: typing.Optional[SubnetType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32d66fb5148d20d001b12c0d2a13afa9f9d62d2ad84dc7e3eccb544d63832e13(
    *,
    command: builtins.str,
    after_network: typing.Optional[builtins.bool] = None,
    cwd: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    group: typing.Optional[builtins.str] = None,
    keep_running: typing.Optional[builtins.bool] = None,
    user: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f5b8e62e9ffc24cea334d4b5b44cfc335970311198fb6a107bf4c7586b1c5da(
    content: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2417045643900e8acec1701e4e4fe91a96c2b290138c6819b1f1003c232a615f(
    os: OperatingSystemType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c54102a3fb4a84adf98707676e047132a6ae8036637677c2d31a8d6f2d11fd39(
    *commands: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__26e31dd2bd42518698d0d4e4ed3b64ee76fbf8301133acbad770f19dfa6ebb33(
    *commands: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d5d1ebe2042e32db54b52ff3c694973ef3f7d0311a257f727d35f9577b02e2fa(
    resource: _Resource_45bc6135,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7e030ab114373c1029fa90c55af2097b08d29de0c6045a2812c36b009d38d3c6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    auto_enable_io: typing.Optional[builtins.bool] = None,
    enable_multi_attach: typing.Optional[builtins.bool] = None,
    encrypted: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_IKey_5f11635f] = None,
    iops: typing.Optional[jsii.Number] = None,
    removal_policy: typing.Optional[_RemovalPolicy_9f93c814] = None,
    size: typing.Optional[_Size_7b441c34] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    throughput: typing.Optional[jsii.Number] = None,
    volume_name: typing.Optional[builtins.str] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e30c09922d73a6f0b71dae72ddb6575e78d3e432fafa10ca51829be8df3b3800(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    volume_id: builtins.str,
    encryption_key: typing.Optional[_IKey_5f11635f] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cdefa3ce29cd54855bbe41af0c55ecff6396ad9df29b998dfebc7ecba9eaac6(
    grantee: _IGrantable_71c4f5de,
    instances: typing.Optional[typing.Sequence[IInstance]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42ca4325f507fbda18080360712b4c2c10961faa37b2164974b01340c7cf0629(
    grantee: _IGrantable_71c4f5de,
    constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
    tag_key_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d727ce06c5eb68be96cf7e88f7ed53367cc010a82a04a06f85d0d9028830f72(
    grantee: _IGrantable_71c4f5de,
    instances: typing.Optional[typing.Sequence[IInstance]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__488166c096839f9076f1efd3133211f3f69a0bac294256f886415b809357f412(
    grantee: _IGrantable_71c4f5de,
    constructs: typing.Sequence[_constructs_77d1e7e8.Construct],
    tag_key_suffix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eee031d929eff737032bb095bb111f3548f3b17ca6e438e9f4791022acd13407(
    *,
    availability_zone: builtins.str,
    volume_id: builtins.str,
    encryption_key: typing.Optional[_IKey_5f11635f] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd11037db838f64c74264a09154568b99584932152ae7679e47051119dcaf1ed(
    *,
    availability_zone: builtins.str,
    auto_enable_io: typing.Optional[builtins.bool] = None,
    enable_multi_attach: typing.Optional[builtins.bool] = None,
    encrypted: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_IKey_5f11635f] = None,
    iops: typing.Optional[jsii.Number] = None,
    removal_policy: typing.Optional[_RemovalPolicy_9f93c814] = None,
    size: typing.Optional[_Size_7b441c34] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
    throughput: typing.Optional[jsii.Number] = None,
    volume_name: typing.Optional[builtins.str] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d4deef82a859d384a072185a8f3c2f8aec1cdbf45accc66513a1568835816af(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
    cidr: typing.Optional[builtins.str] = None,
    create_internet_gateway: typing.Optional[builtins.bool] = None,
    default_instance_tenancy: typing.Optional[DefaultInstanceTenancy] = None,
    enable_dns_hostnames: typing.Optional[builtins.bool] = None,
    enable_dns_support: typing.Optional[builtins.bool] = None,
    flow_logs: typing.Optional[typing.Mapping[builtins.str, typing.Union[FlowLogOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    gateway_endpoints: typing.Optional[typing.Mapping[builtins.str, typing.Union[GatewayVpcEndpointOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    ip_addresses: typing.Optional[IIpAddresses] = None,
    ip_protocol: typing.Optional[IpProtocol] = None,
    ipv6_addresses: typing.Optional[IIpv6Addresses] = None,
    max_azs: typing.Optional[jsii.Number] = None,
    nat_gateway_provider: typing.Optional[NatProvider] = None,
    nat_gateways: typing.Optional[jsii.Number] = None,
    nat_gateway_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    reserved_azs: typing.Optional[jsii.Number] = None,
    restrict_default_security_group: typing.Optional[builtins.bool] = None,
    subnet_configuration: typing.Optional[typing.Sequence[typing.Union[SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_name: typing.Optional[builtins.str] = None,
    vpn_connections: typing.Optional[typing.Mapping[builtins.str, typing.Union[VpnConnectionOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpn_gateway: typing.Optional[builtins.bool] = None,
    vpn_gateway_asn: typing.Optional[jsii.Number] = None,
    vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__985d1aec6a93939347e8e9660018edf018502aaaf73913e84b68821667bd7071(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    is_default: typing.Optional[builtins.bool] = None,
    owner_account_id: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    return_vpn_gateways: typing.Optional[builtins.bool] = None,
    subnet_group_name_tag: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    vpc_id: typing.Optional[builtins.str] = None,
    vpc_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__320b2b7a3ac9d81bbf6917f06aac2a5c2a0d2f83344960158393d5e34d748d41(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zones: typing.Sequence[builtins.str],
    vpc_id: builtins.str,
    isolated_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    region: typing.Optional[builtins.str] = None,
    vpc_cidr_block: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__04f8b7e933af74b695401b45c9c6b308e4684ecde3cb9a2a1e358a336c8f2195(
    id: builtins.str,
    *,
    cidr: builtins.str,
    server_certificate_arn: builtins.str,
    authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
    client_certificate_arn: typing.Optional[builtins.str] = None,
    client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
    client_login_banner: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    logging: typing.Optional[builtins.bool] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
    port: typing.Optional[VpnPort] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    self_service_portal: typing.Optional[builtins.bool] = None,
    session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
    split_tunnel: typing.Optional[builtins.bool] = None,
    transport_protocol: typing.Optional[TransportProtocol] = None,
    user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd705a6fb6eb81dd64ef1fed7a7ff93fff3a4c3c90d6479f35c18eca70fb9d0b(
    id: builtins.str,
    *,
    destination: typing.Optional[FlowLogDestination] = None,
    log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
    max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
    traffic_type: typing.Optional[FlowLogTrafficType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79b57350b260f1ab40e4558402bb9540617b07ec5579d6e503c6d3d0ecad9b09(
    id: builtins.str,
    *,
    service: IGatewayVpcEndpointService,
    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__00d64fd969958beb796ccf5d1bc5d808fd3e751c9e3c2237abfaf2dbe5615a46(
    id: builtins.str,
    *,
    service: IInterfaceVpcEndpointService,
    lookup_supported_azs: typing.Optional[builtins.bool] = None,
    open: typing.Optional[builtins.bool] = None,
    private_dns_enabled: typing.Optional[builtins.bool] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0cc11c2e24387d8a6e5c604fc955974dec83a9a5fc83514fe6bf8d3bc0efaf74(
    id: builtins.str,
    *,
    ip: builtins.str,
    asn: typing.Optional[jsii.Number] = None,
    static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
    tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__579c5c37f3ad43ef55c8403784c0f02c2cc55c98b4122bb2058b45c27041bc73(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fa6d457cb5653a868580011d362ed0a19c899333d9fd8d459bec785f98897e2e(
    *,
    availability_zones: typing.Sequence[builtins.str],
    vpc_id: builtins.str,
    isolated_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    isolated_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    private_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_ipv4_cidr_blocks: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_names: typing.Optional[typing.Sequence[builtins.str]] = None,
    public_subnet_route_table_ids: typing.Optional[typing.Sequence[builtins.str]] = None,
    region: typing.Optional[builtins.str] = None,
    vpc_cidr_block: typing.Optional[builtins.str] = None,
    vpn_gateway_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ca644de10a5f135db39c62e89d37ce660164addf9000f9ca56fb5e67a35f481(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    environment_from_arn: typing.Optional[builtins.str] = None,
    physical_name: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8bc776f89a26beb5c4a733c459442d569ed75b61853b97f02881d59985e22463(
    statement: _PolicyStatement_0fe33853,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__47cfcdd89628cfb671a1d60301cde8a7bfb3bf964b2818f24cf3544b41cb83a8(
    value: typing.Optional[_PolicyDocument_3ac34393],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9a177a308c941d9422cff7194d8a56d967004d3230efd826dc934ef5358129e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc_endpoint_service_load_balancers: typing.Sequence[IVpcEndpointServiceLoadBalancer],
    acceptance_required: typing.Optional[builtins.bool] = None,
    allowed_principals: typing.Optional[typing.Sequence[_ArnPrincipal_d31ca6bc]] = None,
    contributor_insights: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c8d3e17059165270b27192911c5b63d78564836ce9d6a1d2e41f5d272b4c7df6(
    *,
    vpc_endpoint_service_load_balancers: typing.Sequence[IVpcEndpointServiceLoadBalancer],
    acceptance_required: typing.Optional[builtins.bool] = None,
    allowed_principals: typing.Optional[typing.Sequence[_ArnPrincipal_d31ca6bc]] = None,
    contributor_insights: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7730c6b5e42eef600984c48409266eac006c223fb60969799a2d31f3fc5f613b(
    *,
    cidr_block: typing.Optional[builtins.str] = None,
    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
    ipv4_netmask_length: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dff7b53f348ae2cf7efc93ce0f0df35bcb1e7b1b64b7b8a6c57a9924d14268ae(
    *,
    is_default: typing.Optional[builtins.bool] = None,
    owner_account_id: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    return_vpn_gateways: typing.Optional[builtins.bool] = None,
    subnet_group_name_tag: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    vpc_id: typing.Optional[builtins.str] = None,
    vpc_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3cb5105a8b030f970c4d6ccbbc9c8fc7561e1c1fdb31be72509804a81d8a6d11(
    *,
    availability_zones: typing.Optional[typing.Sequence[builtins.str]] = None,
    cidr: typing.Optional[builtins.str] = None,
    create_internet_gateway: typing.Optional[builtins.bool] = None,
    default_instance_tenancy: typing.Optional[DefaultInstanceTenancy] = None,
    enable_dns_hostnames: typing.Optional[builtins.bool] = None,
    enable_dns_support: typing.Optional[builtins.bool] = None,
    flow_logs: typing.Optional[typing.Mapping[builtins.str, typing.Union[FlowLogOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    gateway_endpoints: typing.Optional[typing.Mapping[builtins.str, typing.Union[GatewayVpcEndpointOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    ip_addresses: typing.Optional[IIpAddresses] = None,
    ip_protocol: typing.Optional[IpProtocol] = None,
    ipv6_addresses: typing.Optional[IIpv6Addresses] = None,
    max_azs: typing.Optional[jsii.Number] = None,
    nat_gateway_provider: typing.Optional[NatProvider] = None,
    nat_gateways: typing.Optional[jsii.Number] = None,
    nat_gateway_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    reserved_azs: typing.Optional[jsii.Number] = None,
    restrict_default_security_group: typing.Optional[builtins.bool] = None,
    subnet_configuration: typing.Optional[typing.Sequence[typing.Union[SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_name: typing.Optional[builtins.str] = None,
    vpn_connections: typing.Optional[typing.Mapping[builtins.str, typing.Union[VpnConnectionOptions, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpn_gateway: typing.Optional[builtins.bool] = None,
    vpn_gateway_asn: typing.Optional[jsii.Number] = None,
    vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a901437f27151deb06807ec8a485713c3fcb77d34b4f69a06060baa85e6b178(
    *,
    customer_gateway_asn: jsii.Number,
    customer_gateway_id: builtins.str,
    customer_gateway_ip: builtins.str,
    vpn_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__505d7879dbe9a9268db93b27df2b4b2fe2d7041de89f41a6ed28efe88e72bbe7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    environment_from_arn: typing.Optional[builtins.str] = None,
    physical_name: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1f244e2fd0db7fcc2c7468799c9a19c8b2a0a6f87bbe53904f9e9cf45c6d5c89(
    metric_name: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    color: typing.Optional[builtins.str] = None,
    dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_Duration_4839e8c3] = None,
    region: typing.Optional[builtins.str] = None,
    statistic: typing.Optional[builtins.str] = None,
    unit: typing.Optional[_Unit_61bc6f70] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ff732227dca01f55f135b6bdb24565135067d5dad83456915cda99ffe9a2f9be(
    *,
    ip: builtins.str,
    asn: typing.Optional[jsii.Number] = None,
    static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
    tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8e449d38bf29da9472a911313d5f309a2388d3415c663cf37ec0fe34e62f8909(
    *,
    ip: builtins.str,
    asn: typing.Optional[jsii.Number] = None,
    static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
    tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc: IVpc,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed82ed51aff7000fad288fdd2f04f94c59571252b6810c17b6528b50d626484c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    type: builtins.str,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a626cf8aa20d225a5f0ad2fa027f8c61d183d4e21b0bc1374f5de30f67b20b70(
    *,
    type: builtins.str,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__772a1fa12499f7302933a4967cff0b4e29e035402dda70c99e43af2ae184c046(
    *,
    pre_shared_key: typing.Optional[builtins.str] = None,
    pre_shared_key_secret: typing.Optional[_SecretValue_3dd0ddae] = None,
    tunnel_inside_cidr: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4e19c68e3e7dc3f6551ac414ee3fbb705ea736ea29d1862d436b09746cce7935(
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a9243d0fea7f4d4e8b65c37925a1dbb71b6136866e6c28c37f9d5dc79df4716d(
    *,
    persist: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__968329b6e3d88dbd1836e6234bc305a96628c570666cc423d4eeccc95dc92ab6(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
    edition: typing.Optional[AmazonLinuxEdition] = None,
    kernel: typing.Optional[AmazonLinux2022Kernel] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2a291560388da3a1deca6cc63773b445813e32521bbcf4ece1d3a557e2eda6b(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
    edition: typing.Optional[AmazonLinuxEdition] = None,
    kernel: typing.Optional[AmazonLinux2023Kernel] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8aa3dd8e9489482da5f68eebe827af2a2367490c7299028616bae30c26efbd55(
    *,
    cached_in_context: typing.Optional[builtins.bool] = None,
    user_data: typing.Optional[UserData] = None,
    cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
    edition: typing.Optional[AmazonLinuxEdition] = None,
    kernel: typing.Optional[AmazonLinux2Kernel] = None,
    storage: typing.Optional[AmazonLinuxStorage] = None,
    virtualization: typing.Optional[AmazonLinuxVirt] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cf74508a9d2ec0bb2e7646472ba3fe700482482a3d87536fb58694a37fa01191(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__92a5b88f3339020054ea1e16e9617c17798da0b874294e4200a9b8e5bf598a4b(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    availability_zone: typing.Optional[builtins.str] = None,
    block_devices: typing.Optional[typing.Sequence[typing.Union[BlockDevice, typing.Dict[builtins.str, typing.Any]]]] = None,
    init: typing.Optional[CloudFormationInit] = None,
    init_options: typing.Optional[typing.Union[ApplyCloudFormationInitOptions, typing.Dict[builtins.str, typing.Any]]] = None,
    instance_name: typing.Optional[builtins.str] = None,
    instance_type: typing.Optional[InstanceType] = None,
    machine_image: typing.Optional[IMachineImage] = None,
    require_imdsv2: typing.Optional[builtins.bool] = None,
    security_group: typing.Optional[ISecurityGroup] = None,
    subnet_selection: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f382d5533c0ebd9e4acd85dbfb1d41bb8c0048a0e29c6a90326f07a2f2cd1cf1(
    *peer: IPeer,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30f9648f95fcf6fd4777a67fd46cb5949fb6a0fd2a05b9f89e5cbfe639768592(
    *security_groups: ISecurityGroup,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4af926db4317778330f9d27a35269bd7cc1ff141c2e618cd3478e604ab2cf611(
    other: IConnectable,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a3434f5301bd66f7d9f8219fdf272e0d2c6df758a9c3fd0cdd6179b48ee5580d(
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0fcdad0b62419eb5e4d9089b7ea98359f3c29807c8283229458362a66f03a663(
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__497f73425da5460739cd6f136e19606e6ddef368deba9569817e65819373ecb4(
    other: IConnectable,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6572dc434576da890fbd1b2b5646ecfb304d9804cac739c802d1ee3385a4f805(
    other: IConnectable,
    port_range: Port,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__69cadabf21c2afae1671de35428d0d256a4b57c3e6b3a1334a81e6b9f4c68a3e(
    port_range: Port,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d47a2facfac8c0ecfe23ef6fee5c7521694632daed038efdf40f6905580b1ac4(
    port_range: Port,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1b8ec7d81796ed570e693d5d24043c9d7d899f406915c45c1598080c2100ebf5(
    other: IConnectable,
    port_range: Port,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f82fae2c4334767a87dcacbb402c6b4b78707b965538b5938f6bb6804fc9a4fb(
    port_range: Port,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b918508ccd5634d9e6d60756886cb3101d18d6f4387382a5447e3f16eee02b2(
    other: IConnectable,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25320fe03f4bb5eeafb902dcb6105bd03ab5394914423243b762e469d2ecb045(
    *,
    file_format: typing.Optional[FlowLogFileFormat] = None,
    hive_compatible_partitions: typing.Optional[builtins.bool] = None,
    per_hour_partition: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9009756b359157c5d2b270f95428640becaa73def15e04ee91f0eceba0702608(
    *,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    encrypted: typing.Optional[builtins.bool] = None,
    kms_key: typing.Optional[_IKey_5f11635f] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a0ea3e2bab0709f4d926738afbd8d5ecbd17847b51fb29600f577de41f87b90(
    *,
    delete_on_termination: typing.Optional[builtins.bool] = None,
    iops: typing.Optional[jsii.Number] = None,
    volume_type: typing.Optional[EbsDeviceVolumeType] = None,
    volume_size: typing.Optional[jsii.Number] = None,
    encrypted: typing.Optional[builtins.bool] = None,
    kms_key: typing.Optional[_IKey_5f11635f] = None,
    snapshot_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__40ceead58c1af4de78870bd84bf9515e090aec12292453d603bc5108a17c74db(
    *,
    type: builtins.str,
    amazon_side_asn: typing.Optional[jsii.Number] = None,
    vpn_route_propagation: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ced78745f055b0a1f364c3ae5aeea5e8a341f9b6e72dd88f0e68c7fc2d98cc15(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    resource_type: FlowLogResourceType,
    flow_log_name: typing.Optional[builtins.str] = None,
    destination: typing.Optional[FlowLogDestination] = None,
    log_format: typing.Optional[typing.Sequence[LogFormat]] = None,
    max_aggregation_interval: typing.Optional[FlowLogMaxAggregationInterval] = None,
    traffic_type: typing.Optional[FlowLogTrafficType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dfa0067c45ff01fc5b7b18a93e712842dd36455d40f82bd6f8dbcefab3c653dd(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    flow_log_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8080a5dd19788d6c9b781036167a07af095d42330eb8f6d16be6d15e376362c1(
    name: builtins.str,
    prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1d2c7e50295f087cef1db9b5bb5e8370cec7b96087e793cd5acd56945125f54d(
    ami_map: typing.Mapping[builtins.str, builtins.str],
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fe90514a04aaf5c08a9c469baa518c84e5c6b445bb20b5a77861636475f7c70c(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53da7a1359316eaee152ae1cc7bca00d0af7eb26ba075ac5bddd5aa9912762a3(
    parameter_name: builtins.str,
    os: OperatingSystemType,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a1ebbd79d9f926ea783969c0851038f3bf4ae5f75f35b363e0d68a4baf8b8890(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c7e8d1ab21a95b9a029a944c484e94c08b2faf50a3360bed6944c76aa2e41cea(
    ami_map: typing.Mapping[builtins.str, builtins.str],
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d6165c6e1acd02f0db3c80a8b9118203038aa37e462f1197306722136997d213(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71ea5576b12638380fbef26e998e310527c683321807e9fe504f98321b7d6a34(
    argv: typing.Sequence[builtins.str],
    *,
    cwd: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ignore_errors: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    test_cmd: typing.Optional[builtins.str] = None,
    wait_after_completion: typing.Optional[InitCommandWaitDuration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fda781af7564e97061c3e86997ea287b99b8f620f6e62f1c8083fbd3f3244474(
    shell_command: builtins.str,
    *,
    cwd: typing.Optional[builtins.str] = None,
    env: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    ignore_errors: typing.Optional[builtins.bool] = None,
    key: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    test_cmd: typing.Optional[builtins.str] = None,
    wait_after_completion: typing.Optional[InitCommandWaitDuration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ce391dd6a64744f1d308a93bd2b78efee46c104a775f9153a5171d8a73909fd(
    *,
    base64_encoded: typing.Optional[builtins.bool] = None,
    group: typing.Optional[builtins.str] = None,
    mode: typing.Optional[builtins.str] = None,
    owner: typing.Optional[builtins.str] = None,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    asset_hash: typing.Optional[builtins.str] = None,
    asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
    bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
    follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
    ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
    deploy_time: typing.Optional[builtins.bool] = None,
    readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3d9778b6f3d55d750d385b361f8381c51ee484d3c8920175605233fbe5f951c(
    *,
    service_restart_handles: typing.Optional[typing.Sequence[InitServiceRestartHandle]] = None,
    asset_hash: typing.Optional[builtins.str] = None,
    asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
    bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
    follow_symlinks: typing.Optional[_SymlinkFollowMode_047ec1f6] = None,
    ignore_mode: typing.Optional[_IgnoreMode_655a98e8] = None,
    deploy_time: typing.Optional[builtins.bool] = None,
    readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a11756d82f1033710d89b4b10b111462f7a99734ff79d3648bd84d0e57ff3dc9(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    service: IInterfaceVpcEndpointService,
    lookup_supported_azs: typing.Optional[builtins.bool] = None,
    open: typing.Optional[builtins.bool] = None,
    private_dns_enabled: typing.Optional[builtins.bool] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e163a4ca85dcc83e205f6b431d2755dd7741f92d4c17f842dec2ef54393db5ed(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    port: jsii.Number,
    vpc_endpoint_id: builtins.str,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5987dcbb14ba167119476888ad874e6cdde3a391dfbf6722d7c4a33f74f670c8(
    *commands: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c3b0dbc14c83a0fe273524a287d6117b26bea3d9b86673eedaf99be6f3f4bda4(
    *commands: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9ce752ae4645726bf7e35d37d33fed54a1d1c358bcbedfc878fb63e7fd48b4ac(
    part: MultipartBody,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d12d04d41d5118f934735520c298dd9660e65b22bea96d3ddba69e0a44032da8(
    resource: _Resource_45bc6135,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d7099fb74981d61c8dfdb2cc1b9c36254deb6f003b7e88f104b7a0a351f31e91(
    user_data: UserData,
    content_type: typing.Optional[builtins.str] = None,
    make_default: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53772cd5bc705ccbd691b4063a85c8427a71a5c9fc29d3af5c0a334c7df3f57a(
    subnet: PrivateSubnet,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e5ebef34ffa5d07794eb4c01409ecb54f33bb1760995a5e76e0356ba24dfc061(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ae71ae27f87cc528aa9006d8209d459221ae5f8f2dc1bbea65ed4e53f618dd17(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__667aaaf1a42672f1f3e305988600ce3579dbd1419c23697ce76b29e1e14dc6b7(
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__775f73071cbd2cc2e4cf30b785aba300611f0a810ebc763fc39ebd232b031ee1(
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__023d0f3df05df55fb070badbc7578a4d403248f01084362270140d22d30fc43e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3942619e96cf25a67385636c8f7584fbe8dc092a0ac1deaac68d355a2d7e59d(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__08d76813e07f02784a1108bd81a7030a5244d286c7db7897110323a0dce945bf(
    eip_allocation_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c5cbe91d2f01859af75d3a005f1c18e5cdec09db40b2eb75450b7202ccb792a6(
    *,
    subnet_id: builtins.str,
    availability_zone: typing.Optional[builtins.str] = None,
    ipv4_cidr_block: typing.Optional[builtins.str] = None,
    route_table_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__793cfb4a0cea65797b37d783560d33becbf8df2c9ffa83316226563a465fd0a3(
    *,
    availability_zone: builtins.str,
    cidr_block: builtins.str,
    vpc_id: builtins.str,
    assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
    ipv6_cidr_block: typing.Optional[builtins.str] = None,
    map_public_ip_on_launch: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ad1f4749c744eee2a7aea665daf689e9e745492f79e272f28e7a513dce0d4f6(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    ip: builtins.str,
    asn: typing.Optional[jsii.Number] = None,
    static_routes: typing.Optional[typing.Sequence[builtins.str]] = None,
    tunnel_options: typing.Optional[typing.Sequence[typing.Union[VpnTunnelOption, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2195d4dd860bd8c475c90b56ac0c4772abb9198b6dfc1eb0bda033e9bfba395c(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    customer_gateway_asn: jsii.Number,
    customer_gateway_id: builtins.str,
    customer_gateway_ip: builtins.str,
    vpn_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bae7a2df51c395d1a24d11925c809c17449294a288dc41db5331ecdee31f4f84(
    metric_name: builtins.str,
    *,
    account: typing.Optional[builtins.str] = None,
    color: typing.Optional[builtins.str] = None,
    dimensions_map: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    label: typing.Optional[builtins.str] = None,
    period: typing.Optional[_Duration_4839e8c3] = None,
    region: typing.Optional[builtins.str] = None,
    statistic: typing.Optional[builtins.str] = None,
    unit: typing.Optional[_Unit_61bc6f70] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__32495f3fa6cd0ef19c634059a1e1f8e8a04a16f6bcf1501d64054d951d3876e9(
    version: WindowsVersion,
    *,
    user_data: typing.Optional[UserData] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d36c8ea8f8238c750dcfc9d1f369becc11ed2416802179e3a5e681794171bcf3(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9a2422e1dfabadbd7f572317ed37670a87714b6f36fe9da2a01f1e26e1c69e29(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    cidr: builtins.str,
    server_certificate_arn: builtins.str,
    authorize_all_users_to_vpc_cidr: typing.Optional[builtins.bool] = None,
    client_certificate_arn: typing.Optional[builtins.str] = None,
    client_connection_handler: typing.Optional[IClientVpnConnectionHandler] = None,
    client_login_banner: typing.Optional[builtins.str] = None,
    description: typing.Optional[builtins.str] = None,
    dns_servers: typing.Optional[typing.Sequence[builtins.str]] = None,
    logging: typing.Optional[builtins.bool] = None,
    log_group: typing.Optional[_ILogGroup_3c4fa718] = None,
    log_stream: typing.Optional[_ILogStream_dcfca8c2] = None,
    port: typing.Optional[VpnPort] = None,
    security_groups: typing.Optional[typing.Sequence[ISecurityGroup]] = None,
    self_service_portal: typing.Optional[builtins.bool] = None,
    session_timeout: typing.Optional[ClientVpnSessionTimeout] = None,
    split_tunnel: typing.Optional[builtins.bool] = None,
    transport_protocol: typing.Optional[TransportProtocol] = None,
    user_based_authentication: typing.Optional[ClientVpnUserBasedAuthentication] = None,
    vpc_subnets: typing.Optional[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6c8aae9e1203b18f83d41ca4fddea01d559c58720761ab0edaadc55bd45ea263(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    endpoint_id: builtins.str,
    security_groups: typing.Sequence[ISecurityGroup],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3855a1aa89a893cd0b343fcfc8057121ad85f505d9d981df23ee816d1e3b4178(
    id: builtins.str,
    *,
    cidr: builtins.str,
    description: typing.Optional[builtins.str] = None,
    group_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53fff4bf7ec1dc9a6f6333e9799446eb686a1cd207e61c471f22cfedf94e895d(
    id: builtins.str,
    *,
    cidr: builtins.str,
    target: ClientVpnRouteTarget,
    description: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e6b639e9e272c3dda7a0da668a80b8667ec45c4335a7254fad62ea4903fbf925(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    vpc: IVpc,
    service: IGatewayVpcEndpointService,
    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e30701d75e15889685bae2b128365e2a821d36118234985bd896751e5501712(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    gateway_vpc_endpoint_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass
