aws-cdk.aws-ec2-alpha 2.164.1a0__py3-none-any.whl → 2.166.0a0__py3-none-any.whl

aws_cdk/aws_ec2_alpha/__init__.py

@@ -35,8 +35,6 @@ VpcV2(self, "Vpc",
 
 `VpcV2` does not automatically create subnets or allocate IP addresses, which is different from the `Vpc` construct.
 
-Importing existing VPC in an account into CDK as a `VpcV2` is not yet supported.
-
 ## SubnetV2
 
 `SubnetV2` is a re-write of the [`ec2.Subnet`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Subnet.html) construct.
@@ -59,8 +57,6 @@ SubnetV2(self, "subnetA",
 )
 ```
 
-Same as `VpcV2`, importing existing subnets is not yet supported.
-
 ## IP Addresses Management
 
 By default `VpcV2` uses `10.0.0.0/16` as the primary CIDR if none is defined.
@@ -359,6 +355,127 @@ my_vpc.add_internet_gateway(
     ipv4_destination="192.168.0.0/16"
 )
 ```
+
+## Importing an existing VPC
+
+You can import an existing VPC and its subnets using the `VpcV2.fromVpcV2Attributes()` method or an individual subnet using `SubnetV2.fromSubnetV2Attributes()` method.
+
+### Importing a VPC
+
+To import an existing VPC, use the `VpcV2.fromVpcV2Attributes()` method. You'll need to provide the VPC ID, primary CIDR block, and information about the subnets. You can import secondary address as well created through IPAM, BYOIP(IPv4) or enabled through Amazon Provided IPv6. You must provide VPC Id and its primary CIDR block for importing it.
+
+If you wish to add a new subnet to imported VPC, new subnet's IP range(IPv4) will be validated against provided secondary and primary address block to confirm that it is within the the range of VPC.
+
+Here's an example of importing a VPC with only the required parameters
+
+```python
+stack = Stack()
+
+imported_vpc = VpcV2.from_vpc_v2_attributes(stack, "ImportedVpc",
+    vpc_id="mockVpcID",
+    vpc_cidr_block="10.0.0.0/16"
+)
+```
+
+In case of cross account or cross region VPC, its recommended to provide region and ownerAccountId so that these values for the VPC can be used to populate correct arn value for the VPC. If a VPC region and account ID is not provided, then region and account configured in the stack will be used. Furthermore, these fields will be referenced later while setting up VPC peering connection, so its necessary to set these fields to a correct value.
+
+Below is an example of importing a cross region and cross acount VPC, VPC arn for this case would be 'arn:aws:ec2:us-west-2:123456789012:vpc/mockVpcID'
+
+```python
+stack = Stack()
+
+# Importing a cross acount or cross region VPC
+imported_vpc = VpcV2.from_vpc_v2_attributes(stack, "ImportedVpc",
+    vpc_id="mockVpcID",
+    vpc_cidr_block="10.0.0.0/16",
+    owner_account_id="123456789012",
+    region="us-west-2"
+)
+```
+
+Here's an example of how to import a VPC with multiple CIDR blocks, IPv6 support, and different subnet types:
+
+In this example, we're importing a VPC with:
+
+* A primary CIDR block (10.1.0.0/16)
+* One secondary IPv4 CIDR block (10.2.0.0/16)
+* Two secondary address using IPAM pool (IPv4 and IPv6)
+* VPC has Amazon-provided IPv6 CIDR enabled
+* An isolated subnet in us-west-2a
+* A public subnet in us-west-2b
+
+```python
+stack = Stack()
+
+imported_vpc = VpcV2.from_vpc_v2_attributes(self, "ImportedVPC",
+    vpc_id="vpc-XXX",
+    vpc_cidr_block="10.1.0.0/16",
+    secondary_cidr_blocks=[VPCCidrBlockattributes(
+        cidr_block="10.2.0.0/16",
+        cidr_block_name="ImportedBlock1"
+    ), VPCCidrBlockattributes(
+        ipv6_ipam_pool_id="ipam-pool-XXX",
+        ipv6_netmask_length=52,
+        cidr_block_name="ImportedIpamIpv6"
+    ), VPCCidrBlockattributes(
+        ipv4_ipam_pool_id="ipam-pool-XXX",
+        ipv4_ipam_provisioned_cidrs=["10.2.0.0/16"],
+        cidr_block_name="ImportedIpamIpv4"
+    ), VPCCidrBlockattributes(
+        amazon_provided_ipv6_cidr_block=True
+    )
+    ],
+    subnets=[SubnetV2Attributes(
+        subnet_name="IsolatedSubnet2",
+        subnet_id="subnet-03cd773c0fe08ed26",
+        subnet_type=SubnetType.PRIVATE_ISOLATED,
+        availability_zone="us-west-2a",
+        ipv4_cidr_block="10.2.0.0/24",
+        route_table_id="rtb-0871c310f98da2cbb"
+    ), SubnetV2Attributes(
+        subnet_id="subnet-0fa477e01db27d820",
+        subnet_type=SubnetType.PUBLIC,
+        availability_zone="us-west-2b",
+        ipv4_cidr_block="10.3.0.0/24",
+        route_table_id="rtb-014f3043098fe4b96"
+    )]
+)
+
+# You can now use the imported VPC in your stack
+
+# Adding a new subnet to the imported VPC
+imported_subnet = SubnetV2(self, "NewSubnet",
+    availability_zone="us-west-2a",
+    ipv4_cidr_block=IpCidr("10.2.2.0/24"),
+    vpc=imported_vpc,
+    subnet_type=SubnetType.PUBLIC
+)
+
+# Adding gateways to the imported VPC
+imported_vpc.add_internet_gateway()
+imported_vpc.add_nat_gateway(subnet=imported_subnet)
+imported_vpc.add_egress_only_internet_gateway()
+```
+
+You can add more subnets as needed by including additional entries in the `isolatedSubnets`, `publicSubnets`, or other subnet type arrays (e.g., `privateSubnets`).
+
+### Importing Subnets
+
+You can also import individual subnets using the `SubnetV2.fromSubnetV2Attributes()` method. This is useful when you need to work with specific subnets independently of a VPC.
+
+Here's an example of how to import a subnet:
+
+```python
+SubnetV2.from_subnet_v2_attributes(self, "ImportedSubnet",
+    subnet_id="subnet-0123456789abcdef0",
+    availability_zone="us-west-2a",
+    ipv4_cidr_block="10.2.0.0/24",
+    route_table_id="rtb-0871c310f98da2cbb",
+    subnet_type=SubnetType.PRIVATE_ISOLATED
+)
+```
+
+By importing existing VPCs and subnets, you can easily integrate your existing AWS infrastructure with new resources created through CDK. This is particularly useful when you need to work with pre-existing network configurations or when you're migrating existing infrastructure to CDK.
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -715,6 +832,15 @@ class IIpamPool(typing_extensions.Protocol):
         '''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="ipamIpv4Cidrs")
+    def ipam_ipv4_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Pool CIDR for IPv4 to be provisioned using IPAM Required to check for subnet IP range is within the VPC range.
+
+        :stability: experimental
+        '''
+        ...
+
     @jsii.member(jsii_name="provisionCidr")
     def provision_cidr(
         self,
@@ -761,6 +887,15 @@ class _IIpamPoolProxy:
         '''
         return typing.cast(builtins.str, jsii.get(self, "ipamPoolId"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ipamIpv4Cidrs")
+    def ipam_ipv4_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Pool CIDR for IPv4 to be provisioned using IPAM Required to check for subnet IP range is within the VPC range.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ipamIpv4Cidrs"))
+
     @jsii.member(jsii_name="provisionCidr")
     def provision_cidr(
         self,
@@ -1125,6 +1260,102 @@ class _ISubnetV2Proxy(
 typing.cast(typing.Any, ISubnetV2).__jsii_proxy_class__ = lambda : _ISubnetV2Proxy
 
 
+@jsii.interface(jsii_type="@aws-cdk/aws-ec2-alpha.IVPCCidrBlock")
+class IVPCCidrBlock(typing_extensions.Protocol):
+    '''(experimental) Interface to create L2 for VPC Cidr Block.
+
+    :stability: experimental
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="amazonProvidedIpv6CidrBlock")
+    def amazon_provided_ipv6_cidr_block(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Amazon Provided Ipv6.
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="cidrBlock")
+    def cidr_block(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The secondary IPv4 CIDR Block.
+
+        :default: - no CIDR block provided
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamPoolId")
+    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv4 address type.
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv6IpamPoolId")
+    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv6 address type.
+
+        :stability: experimental
+        '''
+        ...
+
+
+class _IVPCCidrBlockProxy:
+    '''(experimental) Interface to create L2 for VPC Cidr Block.
+
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-ec2-alpha.IVPCCidrBlock"
+
+    @builtins.property
+    @jsii.member(jsii_name="amazonProvidedIpv6CidrBlock")
+    def amazon_provided_ipv6_cidr_block(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Amazon Provided Ipv6.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "amazonProvidedIpv6CidrBlock"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cidrBlock")
+    def cidr_block(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The secondary IPv4 CIDR Block.
+
+        :default: - no CIDR block provided
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "cidrBlock"))
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamPoolId")
+    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv4 address type.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv4IpamPoolId"))
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv6IpamPoolId")
+    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv6 address type.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ipv6IpamPoolId"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IVPCCidrBlock).__jsii_proxy_class__ = lambda : _IVPCCidrBlockProxy
+
+
 @jsii.interface(jsii_type="@aws-cdk/aws-ec2-alpha.IVpcV2")
 class IVpcV2(_aws_cdk_aws_ec2_ceddda9d.IVpc, typing_extensions.Protocol):
     '''(experimental) Placeholder to see what extra props we might need, will be added to original IVPC.
@@ -1145,11 +1376,40 @@ class IVpcV2(_aws_cdk_aws_ec2_ceddda9d.IVpc, typing_extensions.Protocol):
         '''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="ownerAccountId")
+    def owner_account_id(self) -> builtins.str:
+        '''(experimental) The ID of the AWS account that owns the VPC.
+
+        :default: - the account id of the parent stack
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="region")
+    def region(self) -> builtins.str:
+        '''(experimental) Optional to override inferred region.
+
+        :default: - current stack's environment region
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamProvisionedCidrs")
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :stability: experimental
+        '''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="secondaryCidrBlock")
-    def secondary_cidr_block(
-        self,
-    ) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock]:
+    def secondary_cidr_block(self) -> typing.Optional[typing.List[IVPCCidrBlock]]:
         '''(experimental) The secondary CIDR blocks associated with the VPC.
 
         For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.
@@ -1280,18 +1540,47 @@ class _IVpcV2Proxy(
         '''
         return typing.cast(builtins.str, jsii.get(self, "ipv4CidrBlock"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ownerAccountId")
+    def owner_account_id(self) -> builtins.str:
+        '''(experimental) The ID of the AWS account that owns the VPC.
+
+        :default: - the account id of the parent stack
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "ownerAccountId"))
+
+    @builtins.property
+    @jsii.member(jsii_name="region")
+    def region(self) -> builtins.str:
+        '''(experimental) Optional to override inferred region.
+
+        :default: - current stack's environment region
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "region"))
+
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamProvisionedCidrs")
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ipv4IpamProvisionedCidrs"))
+
     @builtins.property
     @jsii.member(jsii_name="secondaryCidrBlock")
-    def secondary_cidr_block(
-        self,
-    ) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock]:
+    def secondary_cidr_block(self) -> typing.Optional[typing.List[IVPCCidrBlock]]:
         '''(experimental) The secondary CIDR blocks associated with the VPC.
 
         For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.
 
         :stability: experimental
         '''
-        return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock], jsii.get(self, "secondaryCidrBlock"))
+        return typing.cast(typing.Optional[typing.List[IVPCCidrBlock]], jsii.get(self, "secondaryCidrBlock"))
 
     @jsii.member(jsii_name="addEgressOnlyInternetGateway")
     def add_egress_only_internet_gateway(
@@ -1808,7 +2097,6 @@ class IpCidr(metaclass=jsii.JSIIMeta, jsii_type="@aws-cdk/aws-ec2-alpha.IpCidr")
 
     Example::
 
-        stack = Stack()
         my_vpc = VpcV2(self, "Vpc")
         route_table = RouteTable(self, "RouteTable",
             vpc=my_vpc
@@ -1817,13 +2105,19 @@ class IpCidr(metaclass=jsii.JSIIMeta, jsii_type="@aws-cdk/aws-ec2-alpha.IpCidr")
             vpc=my_vpc,
             availability_zone="eu-west-2a",
             ipv4_cidr_block=IpCidr("10.0.0.0/24"),
-            subnet_type=SubnetType.PUBLIC
+            subnet_type=SubnetType.PRIVATE_ISOLATED
         )
         
-        my_vpc.add_internet_gateway()
-        my_vpc.add_nat_gateway(
+        natgw = NatGateway(self, "NatGW",
             subnet=subnet,
-            connectivity_type=NatConnectivityType.PUBLIC
+            vpc=my_vpc,
+            connectivity_type=NatConnectivityType.PRIVATE,
+            private_ip_address="10.0.0.42"
+        )
+        Route(self, "NatGwRoute",
+            route_table=route_table,
+            destination="0.0.0.0/0",
+            target={"gateway": natgw}
         )
     '''
 
@@ -3950,7 +4244,6 @@ class SubnetV2(
 
     Example::
 
-        stack = Stack()
         my_vpc = VpcV2(self, "Vpc")
         route_table = RouteTable(self, "RouteTable",
             vpc=my_vpc
@@ -3959,13 +4252,19 @@ class SubnetV2(
             vpc=my_vpc,
             availability_zone="eu-west-2a",
             ipv4_cidr_block=IpCidr("10.0.0.0/24"),
-            subnet_type=SubnetType.PUBLIC
+            subnet_type=SubnetType.PRIVATE_ISOLATED
         )
         
-        my_vpc.add_internet_gateway()
-        my_vpc.add_nat_gateway(
+        natgw = NatGateway(self, "NatGW",
             subnet=subnet,
-            connectivity_type=NatConnectivityType.PUBLIC
+            vpc=my_vpc,
+            connectivity_type=NatConnectivityType.PRIVATE,
+            private_ip_address="10.0.0.42"
+        )
+        Route(self, "NatGwRoute",
+            route_table=route_table,
+            destination="0.0.0.0/0",
+            target={"gateway": natgw}
         )
     '''
 
@@ -4015,6 +4314,51 @@ class SubnetV2(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="fromSubnetV2Attributes")
+    @builtins.classmethod
+    def from_subnet_v2_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        availability_zone: builtins.str,
+        ipv4_cidr_block: builtins.str,
+        subnet_id: builtins.str,
+        subnet_type: _aws_cdk_aws_ec2_ceddda9d.SubnetType,
+        ipv6_cidr_block: typing.Optional[builtins.str] = None,
+        route_table_id: typing.Optional[builtins.str] = None,
+        subnet_name: typing.Optional[builtins.str] = None,
+    ) -> ISubnetV2:
+        '''(experimental) Import an existing subnet to the VPC.
+
+        :param scope: -
+        :param id: -
+        :param availability_zone: (experimental) The Availability Zone this subnet is located in. Default: - No AZ information, cannot use AZ selection features
+        :param ipv4_cidr_block: (experimental) The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
+        :param subnet_id: (experimental) The subnetId for this particular subnet.
+        :param subnet_type: (experimental) The type of subnet (public or private) that this subnet represents.
+        :param ipv6_cidr_block: (experimental) The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
+        :param route_table_id: (experimental) The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints
+        :param subnet_name: (experimental) Name of the given subnet. Default: - no subnet name
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4b7efcb4a40a1cd4c8f364f2028af9d8a2b5e24d65cf7122742bca15d44a40ae)
+            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 = SubnetV2Attributes(
+            availability_zone=availability_zone,
+            ipv4_cidr_block=ipv4_cidr_block,
+            subnet_id=subnet_id,
+            subnet_type=subnet_type,
+            ipv6_cidr_block=ipv6_cidr_block,
+            route_table_id=route_table_id,
+            subnet_name=subnet_name,
+        )
+
+        return typing.cast(ISubnetV2, jsii.sinvoke(cls, "fromSubnetV2Attributes", [scope, id, attrs]))
+
     @jsii.member(jsii_name="associateNetworkAcl")
     def associate_network_acl(
         self,
@@ -4110,88 +4454,252 @@ class SubnetV2(
 
 
 @jsii.data_type(
-    jsii_type="@aws-cdk/aws-ec2-alpha.SubnetV2Props",
+    jsii_type="@aws-cdk/aws-ec2-alpha.SubnetV2Attributes",
     jsii_struct_bases=[],
     name_mapping={
         "availability_zone": "availabilityZone",
         "ipv4_cidr_block": "ipv4CidrBlock",
+        "subnet_id": "subnetId",
         "subnet_type": "subnetType",
-        "vpc": "vpc",
-        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
         "ipv6_cidr_block": "ipv6CidrBlock",
-        "route_table": "routeTable",
+        "route_table_id": "routeTableId",
         "subnet_name": "subnetName",
     },
 )
-class SubnetV2Props:
+class SubnetV2Attributes:
     def __init__(
         self,
         *,
         availability_zone: builtins.str,
-        ipv4_cidr_block: IpCidr,
+        ipv4_cidr_block: builtins.str,
+        subnet_id: builtins.str,
         subnet_type: _aws_cdk_aws_ec2_ceddda9d.SubnetType,
-        vpc: IVpcV2,
-        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
-        ipv6_cidr_block: typing.Optional[IpCidr] = None,
-        route_table: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable] = None,
+        ipv6_cidr_block: typing.Optional[builtins.str] = None,
+        route_table_id: typing.Optional[builtins.str] = None,
         subnet_name: typing.Optional[builtins.str] = None,
     ) -> None:
-        '''(experimental) Properties to define subnet for VPC.
+        '''(experimental) Properties required to import a subnet.
 
-        :param availability_zone: (experimental) Custom AZ for the subnet.
-        :param ipv4_cidr_block: (experimental) ipv4 cidr to assign to this subnet. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-cidrblock
-        :param subnet_type: (experimental) The type of Subnet to configure. The Subnet type will control the ability to route and connect to the Internet. TODO: Add validation check ``subnetType`` when adding resources (e.g. cannot add NatGateway to private)
-        :param vpc: (experimental) VPC Prop.
-        :param assign_ipv6_address_on_creation: (experimental) Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - undefined in case not provided as an input
-        :param ipv6_cidr_block: (experimental) Ipv6 CIDR Range for subnet. Default: - No Ipv6 address
-        :param route_table: (experimental) Custom Route for subnet. Default: - a default route table created
-        :param subnet_name: (experimental) Subnet name. Default: - provisioned with an autogenerated name by CDK
+        :param availability_zone: (experimental) The Availability Zone this subnet is located in. Default: - No AZ information, cannot use AZ selection features
+        :param ipv4_cidr_block: (experimental) The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
+        :param subnet_id: (experimental) The subnetId for this particular subnet.
+        :param subnet_type: (experimental) The type of subnet (public or private) that this subnet represents.
+        :param ipv6_cidr_block: (experimental) The IPv4 CIDR block associated with the subnet. Default: - No CIDR information, cannot use CIDR filter features
+        :param route_table_id: (experimental) The ID of the route table for this particular subnet. Default: - No route table information, cannot create VPC endpoints
+        :param subnet_name: (experimental) Name of the given subnet. Default: - no subnet name
 
         :stability: experimental
         :exampleMetadata: infused
 
         Example::
 
-            stack = Stack()
-            my_vpc = VpcV2(self, "Vpc")
-            route_table = RouteTable(self, "RouteTable",
-                vpc=my_vpc
-            )
-            subnet = SubnetV2(self, "Subnet",
-                vpc=my_vpc,
-                availability_zone="eu-west-2a",
-                ipv4_cidr_block=IpCidr("10.0.0.0/24"),
-                subnet_type=SubnetType.PUBLIC
-            )
-            
-            my_vpc.add_internet_gateway()
-            my_vpc.add_nat_gateway(
-                subnet=subnet,
-                connectivity_type=NatConnectivityType.PUBLIC
+            SubnetV2.from_subnet_v2_attributes(self, "ImportedSubnet",
+                subnet_id="subnet-0123456789abcdef0",
+                availability_zone="us-west-2a",
+                ipv4_cidr_block="10.2.0.0/24",
+                route_table_id="rtb-0871c310f98da2cbb",
+                subnet_type=SubnetType.PRIVATE_ISOLATED
             )
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__95ce99f8025433ac8b79825abef6ff91da4dfd0693fd24dadedcee63eb93d668)
+            type_hints = typing.get_type_hints(_typecheckingstub__d1c1c485159a040f312fb9bac0ed6195b5a11d0519ac42081997619b64a0858c)
             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 subnet_id", value=subnet_id, expected_type=type_hints["subnet_id"])
             check_type(argname="argument subnet_type", value=subnet_type, expected_type=type_hints["subnet_type"])
-            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
-            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 route_table", value=route_table, expected_type=type_hints["route_table"])
+            check_type(argname="argument route_table_id", value=route_table_id, expected_type=type_hints["route_table_id"])
             check_type(argname="argument subnet_name", value=subnet_name, expected_type=type_hints["subnet_name"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "availability_zone": availability_zone,
             "ipv4_cidr_block": ipv4_cidr_block,
+            "subnet_id": subnet_id,
             "subnet_type": subnet_type,
-            "vpc": vpc,
         }
-        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 route_table is not None:
-            self._values["route_table"] = route_table
+        if route_table_id is not None:
+            self._values["route_table_id"] = route_table_id
+        if subnet_name is not None:
+            self._values["subnet_name"] = subnet_name
+
+    @builtins.property
+    def availability_zone(self) -> builtins.str:
+        '''(experimental) The Availability Zone this subnet is located in.
+
+        :default: - No AZ information, cannot use AZ selection features
+
+        :stability: experimental
+        '''
+        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 ipv4_cidr_block(self) -> builtins.str:
+        '''(experimental) The IPv4 CIDR block associated with the subnet.
+
+        :default: - No CIDR information, cannot use CIDR filter features
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv4_cidr_block")
+        assert result is not None, "Required property 'ipv4_cidr_block' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def subnet_id(self) -> builtins.str:
+        '''(experimental) The subnetId for this particular subnet.
+
+        :stability: experimental
+        '''
+        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 subnet_type(self) -> _aws_cdk_aws_ec2_ceddda9d.SubnetType:
+        '''(experimental) The type of subnet (public or private) that this subnet represents.
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_type")
+        assert result is not None, "Required property 'subnet_type' is missing"
+        return typing.cast(_aws_cdk_aws_ec2_ceddda9d.SubnetType, result)
+
+    @builtins.property
+    def ipv6_cidr_block(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The IPv4 CIDR block associated with the subnet.
+
+        :default: - No CIDR information, cannot use CIDR filter features
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv6_cidr_block")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def route_table_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The ID of the route table for this particular subnet.
+
+        :default: - No route table information, cannot create VPC endpoints
+
+        :stability: experimental
+        '''
+        result = self._values.get("route_table_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def subnet_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Name of the given subnet.
+
+        :default: - no subnet name
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_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 "SubnetV2Attributes(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-ec2-alpha.SubnetV2Props",
+    jsii_struct_bases=[],
+    name_mapping={
+        "availability_zone": "availabilityZone",
+        "ipv4_cidr_block": "ipv4CidrBlock",
+        "subnet_type": "subnetType",
+        "vpc": "vpc",
+        "assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
+        "ipv6_cidr_block": "ipv6CidrBlock",
+        "route_table": "routeTable",
+        "subnet_name": "subnetName",
+    },
+)
+class SubnetV2Props:
+    def __init__(
+        self,
+        *,
+        availability_zone: builtins.str,
+        ipv4_cidr_block: IpCidr,
+        subnet_type: _aws_cdk_aws_ec2_ceddda9d.SubnetType,
+        vpc: IVpcV2,
+        assign_ipv6_address_on_creation: typing.Optional[builtins.bool] = None,
+        ipv6_cidr_block: typing.Optional[IpCidr] = None,
+        route_table: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable] = None,
+        subnet_name: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Properties to define subnet for VPC.
+
+        :param availability_zone: (experimental) Custom AZ for the subnet.
+        :param ipv4_cidr_block: (experimental) ipv4 cidr to assign to this subnet. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-cidrblock
+        :param subnet_type: (experimental) The type of Subnet to configure. The Subnet type will control the ability to route and connect to the Internet. TODO: Add validation check ``subnetType`` when adding resources (e.g. cannot add NatGateway to private)
+        :param vpc: (experimental) VPC Prop.
+        :param assign_ipv6_address_on_creation: (experimental) Indicates whether a network interface created in this subnet receives an IPv6 address. If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock. Default: - undefined in case not provided as an input
+        :param ipv6_cidr_block: (experimental) Ipv6 CIDR Range for subnet. Default: - No Ipv6 address
+        :param route_table: (experimental) Custom Route for subnet. Default: - a default route table created
+        :param subnet_name: (experimental) Subnet name. Default: - provisioned with an autogenerated name by CDK
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            my_vpc = VpcV2(self, "Vpc")
+            route_table = RouteTable(self, "RouteTable",
+                vpc=my_vpc
+            )
+            subnet = SubnetV2(self, "Subnet",
+                vpc=my_vpc,
+                availability_zone="eu-west-2a",
+                ipv4_cidr_block=IpCidr("10.0.0.0/24"),
+                subnet_type=SubnetType.PRIVATE_ISOLATED
+            )
+            
+            natgw = NatGateway(self, "NatGW",
+                subnet=subnet,
+                vpc=my_vpc,
+                connectivity_type=NatConnectivityType.PRIVATE,
+                private_ip_address="10.0.0.42"
+            )
+            Route(self, "NatGwRoute",
+                route_table=route_table,
+                destination="0.0.0.0/0",
+                target={"gateway": natgw}
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__95ce99f8025433ac8b79825abef6ff91da4dfd0693fd24dadedcee63eb93d668)
+            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 subnet_type", value=subnet_type, expected_type=type_hints["subnet_type"])
+            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
+            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 route_table", value=route_table, expected_type=type_hints["route_table"])
+            check_type(argname="argument subnet_name", value=subnet_name, expected_type=type_hints["subnet_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "availability_zone": availability_zone,
+            "ipv4_cidr_block": ipv4_cidr_block,
+            "subnet_type": subnet_type,
+            "vpc": vpc,
+        }
+        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 route_table is not None:
+            self._values["route_table"] = route_table
         if subnet_name is not None:
             self._values["subnet_name"] = subnet_name
 
@@ -4256,37 +4764,223 @@ class SubnetV2Props:
         return typing.cast(typing.Optional[builtins.bool], result)
 
     @builtins.property
-    def ipv6_cidr_block(self) -> typing.Optional[IpCidr]:
-        '''(experimental) Ipv6 CIDR Range for subnet.
+    def ipv6_cidr_block(self) -> typing.Optional[IpCidr]:
+        '''(experimental) Ipv6 CIDR Range for subnet.
+
+        :default: - No Ipv6 address
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv6_cidr_block")
+        return typing.cast(typing.Optional[IpCidr], result)
+
+    @builtins.property
+    def route_table(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable]:
+        '''(experimental) Custom Route for subnet.
+
+        :default: - a default route table created
+
+        :stability: experimental
+        '''
+        result = self._values.get("route_table")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable], result)
+
+    @builtins.property
+    def subnet_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Subnet name.
+
+        :default: - provisioned with an autogenerated name by CDK
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnet_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 "SubnetV2Props(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-ec2-alpha.VPCCidrBlockattributes",
+    jsii_struct_bases=[],
+    name_mapping={
+        "amazon_provided_ipv6_cidr_block": "amazonProvidedIpv6CidrBlock",
+        "cidr_block": "cidrBlock",
+        "cidr_block_name": "cidrBlockName",
+        "ipv4_ipam_pool_id": "ipv4IpamPoolId",
+        "ipv4_ipam_provisioned_cidrs": "ipv4IpamProvisionedCidrs",
+        "ipv4_netmask_length": "ipv4NetmaskLength",
+        "ipv6_ipam_pool_id": "ipv6IpamPoolId",
+        "ipv6_netmask_length": "ipv6NetmaskLength",
+    },
+)
+class VPCCidrBlockattributes:
+    def __init__(
+        self,
+        *,
+        amazon_provided_ipv6_cidr_block: typing.Optional[builtins.bool] = None,
+        cidr_block: typing.Optional[builtins.str] = None,
+        cidr_block_name: typing.Optional[builtins.str] = None,
+        ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
+        ipv4_ipam_provisioned_cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
+        ipv4_netmask_length: typing.Optional[jsii.Number] = None,
+        ipv6_ipam_pool_id: typing.Optional[builtins.str] = None,
+        ipv6_netmask_length: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''(experimental) Attributes for VPCCidrBlock used for defining a new CIDR Block and also for importing an existing CIDR.
+
+        :param amazon_provided_ipv6_cidr_block: (experimental) Amazon Provided Ipv6. Default: false
+        :param cidr_block: (experimental) The secondary IPv4 CIDR Block. Default: - no CIDR block provided
+        :param cidr_block_name: (experimental) The secondary IPv4 CIDR Block. Default: - no CIDR block provided
+        :param ipv4_ipam_pool_id: (experimental) IPAM pool for IPv4 address type. Default: - no IPAM pool Id provided for IPv4
+        :param ipv4_ipam_provisioned_cidrs: (experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool. Default: - no IPAM IPv4 CIDR range is provisioned using IPAM
+        :param ipv4_netmask_length: (experimental) Net mask length for IPv4 address type. Default: - no Net mask length configured for IPv4
+        :param ipv6_ipam_pool_id: (experimental) IPAM pool for IPv6 address type. Default: - no IPAM pool Id provided for IPv6
+        :param ipv6_netmask_length: (experimental) Net mask length for IPv6 address type. Default: - no Net mask length configured for IPv6
+
+        :stability: experimental
+        :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.aws_ec2_alpha as ec2_alpha
+            
+            v_pCCidr_blockattributes = ec2_alpha.VPCCidrBlockattributes(
+                amazon_provided_ipv6_cidr_block=False,
+                cidr_block="cidrBlock",
+                cidr_block_name="cidrBlockName",
+                ipv4_ipam_pool_id="ipv4IpamPoolId",
+                ipv4_ipam_provisioned_cidrs=["ipv4IpamProvisionedCidrs"],
+                ipv4_netmask_length=123,
+                ipv6_ipam_pool_id="ipv6IpamPoolId",
+                ipv6_netmask_length=123
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4302f03d1c3aa687fb9a6d3011f239c94d844badf36d9d2e8270a543f80a5d49)
+            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 cidr_block_name", value=cidr_block_name, expected_type=type_hints["cidr_block_name"])
+            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_ipam_provisioned_cidrs", value=ipv4_ipam_provisioned_cidrs, expected_type=type_hints["ipv4_ipam_provisioned_cidrs"])
+            check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
+            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] = {}
+        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 cidr_block_name is not None:
+            self._values["cidr_block_name"] = cidr_block_name
+        if ipv4_ipam_pool_id is not None:
+            self._values["ipv4_ipam_pool_id"] = ipv4_ipam_pool_id
+        if ipv4_ipam_provisioned_cidrs is not None:
+            self._values["ipv4_ipam_provisioned_cidrs"] = ipv4_ipam_provisioned_cidrs
+        if ipv4_netmask_length is not None:
+            self._values["ipv4_netmask_length"] = ipv4_netmask_length
+        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 amazon_provided_ipv6_cidr_block(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Amazon Provided Ipv6.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("amazon_provided_ipv6_cidr_block")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def cidr_block(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The secondary IPv4 CIDR Block.
+
+        :default: - no CIDR block provided
+
+        :stability: experimental
+        '''
+        result = self._values.get("cidr_block")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def cidr_block_name(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The secondary IPv4 CIDR Block.
+
+        :default: - no CIDR block provided
+
+        :stability: experimental
+        '''
+        result = self._values.get("cidr_block_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def ipv4_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv4 address type.
+
+        :default: - no IPAM pool Id provided for IPv4
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv4_ipam_pool_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :default: - no IPAM IPv4 CIDR range is provisioned using IPAM
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv4_ipam_provisioned_cidrs")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Net mask length for IPv4 address type.
 
-        :default: - No Ipv6 address
+        :default: - no Net mask length configured for IPv4
 
         :stability: experimental
         '''
-        result = self._values.get("ipv6_cidr_block")
-        return typing.cast(typing.Optional[IpCidr], result)
+        result = self._values.get("ipv4_netmask_length")
+        return typing.cast(typing.Optional[jsii.Number], result)
 
     @builtins.property
-    def route_table(self) -> typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable]:
-        '''(experimental) Custom Route for subnet.
+    def ipv6_ipam_pool_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) IPAM pool for IPv6 address type.
 
-        :default: - a default route table created
+        :default: - no IPAM pool Id provided for IPv6
 
         :stability: experimental
         '''
-        result = self._values.get("route_table")
-        return typing.cast(typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IRouteTable], result)
+        result = self._values.get("ipv6_ipam_pool_id")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
-    def subnet_name(self) -> typing.Optional[builtins.str]:
-        '''(experimental) Subnet name.
+    def ipv6_netmask_length(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) Net mask length for IPv6 address type.
 
-        :default: - provisioned with an autogenerated name by CDK
+        :default: - no Net mask length configured for IPv6
 
         :stability: experimental
         '''
-        result = self._values.get("subnet_name")
-        return typing.cast(typing.Optional[builtins.str], result)
+        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
@@ -4295,7 +4989,7 @@ class SubnetV2Props:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "SubnetV2Props(%s)" % ", ".join(
+        return "VPCCidrBlockattributes(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -4682,6 +5376,7 @@ class VPNGatewayV2Props(VPNGatewayV2Options):
         "dependencies": "dependencies",
         "ipv4_cidr_block": "ipv4CidrBlock",
         "ipv4_ipam_pool": "ipv4IpamPool",
+        "ipv4_ipam_provisioned_cidrs": "ipv4IpamProvisionedCidrs",
         "ipv4_netmask_length": "ipv4NetmaskLength",
         "ipv6_ipam_pool": "ipv6IpamPool",
         "ipv6_netmask_length": "ipv6NetmaskLength",
@@ -4696,6 +5391,7 @@ class VpcCidrOptions:
         dependencies: typing.Optional[typing.Sequence[_aws_cdk_ceddda9d.CfnResource]] = None,
         ipv4_cidr_block: typing.Optional[builtins.str] = None,
         ipv4_ipam_pool: typing.Optional[IIpamPool] = None,
+        ipv4_ipam_provisioned_cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
         ipv4_netmask_length: typing.Optional[jsii.Number] = None,
         ipv6_ipam_pool: typing.Optional[IIpamPool] = None,
         ipv6_netmask_length: typing.Optional[jsii.Number] = None,
@@ -4707,6 +5403,7 @@ class VpcCidrOptions:
         :param dependencies: (experimental) Dependency to associate Ipv6 CIDR block. Default: - No dependency
         :param ipv4_cidr_block: (experimental) IPv4 CIDR Block. Default: '10.0.0.0/16'
         :param ipv4_ipam_pool: (experimental) Ipv4 IPAM Pool. Default: - Only required when using IPAM Ipv4
+        :param ipv4_ipam_provisioned_cidrs: (experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool. Default: - no IPAM IPv4 CIDR range is provisioned using IPAM
         :param ipv4_netmask_length: (experimental) CIDR Mask for Vpc. Default: - Only required when using IPAM Ipv4
         :param ipv6_ipam_pool: (experimental) Ipv6 IPAM pool id for VPC range, can only be defined under public scope. Default: - no pool id
         :param ipv6_netmask_length: (experimental) CIDR Mask for Vpc. Default: - Only required when using AWS Ipam
@@ -4730,6 +5427,7 @@ class VpcCidrOptions:
                 dependencies=[cfn_resource],
                 ipv4_cidr_block="ipv4CidrBlock",
                 ipv4_ipam_pool=ipam_pool,
+                ipv4_ipam_provisioned_cidrs=["ipv4IpamProvisionedCidrs"],
                 ipv4_netmask_length=123,
                 ipv6_ipam_pool=ipam_pool,
                 ipv6_netmask_length=123
@@ -4742,6 +5440,7 @@ class VpcCidrOptions:
             check_type(argname="argument dependencies", value=dependencies, expected_type=type_hints["dependencies"])
             check_type(argname="argument ipv4_cidr_block", value=ipv4_cidr_block, expected_type=type_hints["ipv4_cidr_block"])
             check_type(argname="argument ipv4_ipam_pool", value=ipv4_ipam_pool, expected_type=type_hints["ipv4_ipam_pool"])
+            check_type(argname="argument ipv4_ipam_provisioned_cidrs", value=ipv4_ipam_provisioned_cidrs, expected_type=type_hints["ipv4_ipam_provisioned_cidrs"])
             check_type(argname="argument ipv4_netmask_length", value=ipv4_netmask_length, expected_type=type_hints["ipv4_netmask_length"])
             check_type(argname="argument ipv6_ipam_pool", value=ipv6_ipam_pool, expected_type=type_hints["ipv6_ipam_pool"])
             check_type(argname="argument ipv6_netmask_length", value=ipv6_netmask_length, expected_type=type_hints["ipv6_netmask_length"])
@@ -4756,6 +5455,8 @@ class VpcCidrOptions:
             self._values["ipv4_cidr_block"] = ipv4_cidr_block
         if ipv4_ipam_pool is not None:
             self._values["ipv4_ipam_pool"] = ipv4_ipam_pool
+        if ipv4_ipam_provisioned_cidrs is not None:
+            self._values["ipv4_ipam_provisioned_cidrs"] = ipv4_ipam_provisioned_cidrs
         if ipv4_netmask_length is not None:
             self._values["ipv4_netmask_length"] = ipv4_netmask_length
         if ipv6_ipam_pool is not None:
@@ -4820,6 +5521,17 @@ class VpcCidrOptions:
         result = self._values.get("ipv4_ipam_pool")
         return typing.cast(typing.Optional[IIpamPool], result)
 
+    @builtins.property
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :default: - no IPAM IPv4 CIDR range is provisioned using IPAM
+
+        :stability: experimental
+        '''
+        result = self._values.get("ipv4_ipam_provisioned_cidrs")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     @builtins.property
     def ipv4_netmask_length(self) -> typing.Optional[jsii.Number]:
         '''(experimental) CIDR Mask for Vpc.
@@ -4865,6 +5577,169 @@ class VpcCidrOptions:
         )
 
 
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-ec2-alpha.VpcV2Attributes",
+    jsii_struct_bases=[],
+    name_mapping={
+        "vpc_cidr_block": "vpcCidrBlock",
+        "vpc_id": "vpcId",
+        "owner_account_id": "ownerAccountId",
+        "region": "region",
+        "secondary_cidr_blocks": "secondaryCidrBlocks",
+        "subnets": "subnets",
+        "vpn_gateway_id": "vpnGatewayId",
+    },
+)
+class VpcV2Attributes:
+    def __init__(
+        self,
+        *,
+        vpc_cidr_block: builtins.str,
+        vpc_id: builtins.str,
+        owner_account_id: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        secondary_cidr_blocks: typing.Optional[typing.Sequence[typing.Union[VPCCidrBlockattributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+        subnets: typing.Optional[typing.Sequence[typing.Union[SubnetV2Attributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpn_gateway_id: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''(experimental) Options to import a VPC created outside of CDK stack.
+
+        :param vpc_cidr_block: (experimental) Primary VPC CIDR Block of the imported VPC Can only be IPv4.
+        :param vpc_id: (experimental) The VPC ID Refers to physical Id of the resource.
+        :param owner_account_id: (experimental) The ID of the AWS account that owns the imported VPC required in case of cross account VPC as given value will be used to set field account for imported VPC, which then later can be used for establishing VPC peering connection. Default: - constructed with stack account value
+        :param region: (experimental) Region in which imported VPC is hosted required in case of cross region VPC as given value will be used to set field region for imported VPC, which then later can be used for establishing VPC peering connection. Default: - constructed with stack region value
+        :param secondary_cidr_blocks: (experimental) Import Secondary CIDR blocks associated with VPC. Default: - No secondary IP address
+        :param subnets: (experimental) Subnets associated with imported VPC. Default: - no subnets provided to be imported
+        :param vpn_gateway_id: (experimental) A VPN Gateway is attached to the VPC. Default: - No VPN Gateway
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            stack = Stack()
+            
+            # Importing a cross acount or cross region VPC
+            imported_vpc = VpcV2.from_vpc_v2_attributes(stack, "ImportedVpc",
+                vpc_id="mockVpcID",
+                vpc_cidr_block="10.0.0.0/16",
+                owner_account_id="123456789012",
+                region="us-west-2"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__456e1aed5fd7b92e9fe1ffc4615970b62870dbb14e689177f2fdb104f3200b6b)
+            check_type(argname="argument vpc_cidr_block", value=vpc_cidr_block, expected_type=type_hints["vpc_cidr_block"])
+            check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
+            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 secondary_cidr_blocks", value=secondary_cidr_blocks, expected_type=type_hints["secondary_cidr_blocks"])
+            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
+            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_cidr_block": vpc_cidr_block,
+            "vpc_id": vpc_id,
+        }
+        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 secondary_cidr_blocks is not None:
+            self._values["secondary_cidr_blocks"] = secondary_cidr_blocks
+        if subnets is not None:
+            self._values["subnets"] = subnets
+        if vpn_gateway_id is not None:
+            self._values["vpn_gateway_id"] = vpn_gateway_id
+
+    @builtins.property
+    def vpc_cidr_block(self) -> builtins.str:
+        '''(experimental) Primary VPC CIDR Block of the imported VPC Can only be IPv4.
+
+        :stability: experimental
+        '''
+        result = self._values.get("vpc_cidr_block")
+        assert result is not None, "Required property 'vpc_cidr_block' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def vpc_id(self) -> builtins.str:
+        '''(experimental) The VPC ID Refers to physical Id of the resource.
+
+        :stability: experimental
+        '''
+        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 owner_account_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The ID of the AWS account that owns the imported VPC required in case of cross account VPC as given value will be used to set field account for imported VPC, which then later can be used for establishing VPC peering connection.
+
+        :default: - constructed with stack account value
+
+        :stability: experimental
+        '''
+        result = self._values.get("owner_account_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def region(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Region in which imported VPC is hosted required in case of cross region VPC as given value will be used to set field region for imported VPC, which then later can be used for establishing VPC peering connection.
+
+        :default: - constructed with stack region value
+
+        :stability: experimental
+        '''
+        result = self._values.get("region")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def secondary_cidr_blocks(
+        self,
+    ) -> typing.Optional[typing.List[VPCCidrBlockattributes]]:
+        '''(experimental) Import Secondary CIDR blocks associated with VPC.
+
+        :default: - No secondary IP address
+
+        :stability: experimental
+        '''
+        result = self._values.get("secondary_cidr_blocks")
+        return typing.cast(typing.Optional[typing.List[VPCCidrBlockattributes]], result)
+
+    @builtins.property
+    def subnets(self) -> typing.Optional[typing.List[SubnetV2Attributes]]:
+        '''(experimental) Subnets associated with imported VPC.
+
+        :default: - no subnets provided to be imported
+
+        :stability: experimental
+        '''
+        result = self._values.get("subnets")
+        return typing.cast(typing.Optional[typing.List[SubnetV2Attributes]], result)
+
+    @builtins.property
+    def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
+        '''(experimental) A VPN Gateway is attached to the VPC.
+
+        :default: - No VPN Gateway
+
+        :stability: experimental
+        '''
+        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 "VpcV2Attributes(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(IVpcV2)
 class VpcV2Base(
     _aws_cdk_ceddda9d.Resource,
@@ -5361,6 +6236,16 @@ class VpcV2Base(
         '''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="ownerAccountId")
+    @abc.abstractmethod
+    def owner_account_id(self) -> builtins.str:
+        '''(experimental) Identifier of the owner for this VPC.
+
+        :stability: experimental
+        '''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="privateSubnets")
     def private_subnets(self) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet]:
@@ -5380,12 +6265,10 @@ class VpcV2Base(
         return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet], jsii.get(self, "publicSubnets"))
 
     @builtins.property
-    @jsii.member(jsii_name="secondaryCidrBlock")
+    @jsii.member(jsii_name="region")
     @abc.abstractmethod
-    def secondary_cidr_block(
-        self,
-    ) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock]:
-        '''(experimental) Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6 Ipv4 should be within RFC#1918 range.
+    def region(self) -> builtins.str:
+        '''(experimental) Region for this VPC.
 
         :stability: experimental
         '''
@@ -5430,6 +6313,26 @@ class VpcV2Base(
         '''
         return typing.cast(typing.Optional[builtins.str], jsii.get(self, "internetGatewayId"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamProvisionedCidrs")
+    @abc.abstractmethod
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :stability: experimental
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="secondaryCidrBlock")
+    @abc.abstractmethod
+    def secondary_cidr_block(self) -> typing.Optional[typing.List[IVPCCidrBlock]]:
+        '''(experimental) Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6 Ipv4 should be within RFC#1918 range.
+
+        :stability: experimental
+        '''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="vpnGatewayId")
     def vpn_gateway_id(self) -> typing.Optional[builtins.str]:
@@ -5492,15 +6395,22 @@ class _VpcV2BaseProxy(
         return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet], jsii.get(self, "isolatedSubnets"))
 
     @builtins.property
-    @jsii.member(jsii_name="secondaryCidrBlock")
-    def secondary_cidr_block(
-        self,
-    ) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock]:
-        '''(experimental) Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6 Ipv4 should be within RFC#1918 range.
+    @jsii.member(jsii_name="ownerAccountId")
+    def owner_account_id(self) -> builtins.str:
+        '''(experimental) Identifier of the owner for this VPC.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "ownerAccountId"))
+
+    @builtins.property
+    @jsii.member(jsii_name="region")
+    def region(self) -> builtins.str:
+        '''(experimental) Region for this VPC.
 
         :stability: experimental
         '''
-        return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock], jsii.get(self, "secondaryCidrBlock"))
+        return typing.cast(builtins.str, jsii.get(self, "region"))
 
     @builtins.property
     @jsii.member(jsii_name="vpcArn")
@@ -5529,6 +6439,24 @@ class _VpcV2BaseProxy(
         '''
         return typing.cast(builtins.str, jsii.get(self, "vpcId"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamProvisionedCidrs")
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned under pool Required to check for overlapping CIDRs after provisioning is complete under IPAM pool.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ipv4IpamProvisionedCidrs"))
+
+    @builtins.property
+    @jsii.member(jsii_name="secondaryCidrBlock")
+    def secondary_cidr_block(self) -> typing.Optional[typing.List[IVPCCidrBlock]]:
+        '''(experimental) Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6 Ipv4 should be within RFC#1918 range.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[IVPCCidrBlock]], jsii.get(self, "secondaryCidrBlock"))
+
 # Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
 typing.cast(typing.Any, VpcV2Base).__jsii_proxy_class__ = lambda : _VpcV2BaseProxy
 
@@ -5861,6 +6789,51 @@ class VpcV2(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="fromVpcV2Attributes")
+    @builtins.classmethod
+    def from_vpc_v2_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        vpc_cidr_block: builtins.str,
+        vpc_id: builtins.str,
+        owner_account_id: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        secondary_cidr_blocks: typing.Optional[typing.Sequence[typing.Union[VPCCidrBlockattributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+        subnets: typing.Optional[typing.Sequence[typing.Union[SubnetV2Attributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+        vpn_gateway_id: typing.Optional[builtins.str] = None,
+    ) -> IVpcV2:
+        '''(experimental) Create a VPC from existing attributes.
+
+        :param scope: -
+        :param id: -
+        :param vpc_cidr_block: (experimental) Primary VPC CIDR Block of the imported VPC Can only be IPv4.
+        :param vpc_id: (experimental) The VPC ID Refers to physical Id of the resource.
+        :param owner_account_id: (experimental) The ID of the AWS account that owns the imported VPC required in case of cross account VPC as given value will be used to set field account for imported VPC, which then later can be used for establishing VPC peering connection. Default: - constructed with stack account value
+        :param region: (experimental) Region in which imported VPC is hosted required in case of cross region VPC as given value will be used to set field region for imported VPC, which then later can be used for establishing VPC peering connection. Default: - constructed with stack region value
+        :param secondary_cidr_blocks: (experimental) Import Secondary CIDR blocks associated with VPC. Default: - No secondary IP address
+        :param subnets: (experimental) Subnets associated with imported VPC. Default: - no subnets provided to be imported
+        :param vpn_gateway_id: (experimental) A VPN Gateway is attached to the VPC. Default: - No VPN Gateway
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a44e5d77c989876de48b8f71adf0b240f0b6a3149cc8bd0c5ab7bb8df6f6791f)
+            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 = VpcV2Attributes(
+            vpc_cidr_block=vpc_cidr_block,
+            vpc_id=vpc_id,
+            owner_account_id=owner_account_id,
+            region=region,
+            secondary_cidr_blocks=secondary_cidr_blocks,
+            subnets=subnets,
+            vpn_gateway_id=vpn_gateway_id,
+        )
+
+        return typing.cast(IVpcV2, jsii.sinvoke(cls, "fromVpcV2Attributes", [scope, id, attrs]))
+
     @builtins.property
     @jsii.member(jsii_name="dnsHostnamesEnabled")
     def dns_hostnames_enabled(self) -> builtins.bool:
@@ -5930,6 +6903,15 @@ class VpcV2(
         '''
         return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet], jsii.get(self, "isolatedSubnets"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ownerAccountId")
+    def owner_account_id(self) -> builtins.str:
+        '''(experimental) Identifier of the owner for this VPC.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "ownerAccountId"))
+
     @builtins.property
     @jsii.member(jsii_name="privateSubnets")
     def private_subnets(self) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet]:
@@ -5949,24 +6931,22 @@ class VpcV2(
         return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.ISubnet], jsii.get(self, "publicSubnets"))
 
     @builtins.property
-    @jsii.member(jsii_name="resource")
-    def resource(self) -> _aws_cdk_aws_ec2_ceddda9d.CfnVPC:
-        '''(experimental) The AWS CloudFormation resource representing the VPC.
+    @jsii.member(jsii_name="region")
+    def region(self) -> builtins.str:
+        '''(experimental) Region for this VPC.
 
         :stability: experimental
         '''
-        return typing.cast(_aws_cdk_aws_ec2_ceddda9d.CfnVPC, jsii.get(self, "resource"))
+        return typing.cast(builtins.str, jsii.get(self, "region"))
 
     @builtins.property
-    @jsii.member(jsii_name="secondaryCidrBlock")
-    def secondary_cidr_block(
-        self,
-    ) -> typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock]:
-        '''(experimental) reference to all secondary blocks attached.
+    @jsii.member(jsii_name="resource")
+    def resource(self) -> _aws_cdk_aws_ec2_ceddda9d.CfnVPC:
+        '''(experimental) The AWS CloudFormation resource representing the VPC.
 
         :stability: experimental
         '''
-        return typing.cast(typing.List[_aws_cdk_aws_ec2_ceddda9d.CfnVPCCidrBlock], jsii.get(self, "secondaryCidrBlock"))
+        return typing.cast(_aws_cdk_aws_ec2_ceddda9d.CfnVPC, jsii.get(self, "resource"))
 
     @builtins.property
     @jsii.member(jsii_name="useIpv6")
@@ -6008,6 +6988,24 @@ class VpcV2(
         '''
         return typing.cast(builtins.str, jsii.get(self, "vpcId"))
 
+    @builtins.property
+    @jsii.member(jsii_name="ipv4IpamProvisionedCidrs")
+    def ipv4_ipam_provisioned_cidrs(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) IPv4 CIDR provisioned using IPAM pool Required to check for overlapping CIDRs after provisioning is complete under IPAM.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "ipv4IpamProvisionedCidrs"))
+
+    @builtins.property
+    @jsii.member(jsii_name="secondaryCidrBlock")
+    def secondary_cidr_block(self) -> typing.Optional[typing.List[IVPCCidrBlock]]:
+        '''(experimental) reference to all secondary blocks attached.
+
+        :stability: experimental
+        '''
+        return typing.cast(typing.Optional[typing.List[IVPCCidrBlock]], jsii.get(self, "secondaryCidrBlock"))
+
 
 __all__ = [
     "AddressFamily",
@@ -6021,6 +7019,7 @@ __all__ = [
     "IRouteTarget",
     "IRouteV2",
     "ISubnetV2",
+    "IVPCCidrBlock",
     "IVpcV2",
     "InternetGateway",
     "InternetGatewayOptions",
@@ -6047,12 +7046,15 @@ __all__ = [
     "RouteTargetType",
     "SecondaryAddressProps",
     "SubnetV2",
+    "SubnetV2Attributes",
     "SubnetV2Props",
+    "VPCCidrBlockattributes",
     "VPNGatewayV2",
     "VPNGatewayV2Options",
     "VPNGatewayV2Props",
     "VpcCidrOptions",
     "VpcV2",
+    "VpcV2Attributes",
     "VpcV2Base",
     "VpcV2Props",
 ]
@@ -6326,6 +7328,21 @@ def _typecheckingstub__df9294d0dd8fd099bad5e4bd408f0f8b8bffbcdc6e4f624de6a1bf541
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4b7efcb4a40a1cd4c8f364f2028af9d8a2b5e24d65cf7122742bca15d44a40ae(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    availability_zone: builtins.str,
+    ipv4_cidr_block: builtins.str,
+    subnet_id: builtins.str,
+    subnet_type: _aws_cdk_aws_ec2_ceddda9d.SubnetType,
+    ipv6_cidr_block: typing.Optional[builtins.str] = None,
+    route_table_id: typing.Optional[builtins.str] = None,
+    subnet_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c5ecedf09cdae417f7675efd5f583cb5bfabde2a1b69f4f330c6434c1020e903(
     id: builtins.str,
     network_acl: _aws_cdk_aws_ec2_ceddda9d.INetworkAcl,
@@ -6333,6 +7350,19 @@ def _typecheckingstub__c5ecedf09cdae417f7675efd5f583cb5bfabde2a1b69f4f330c6434c1
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d1c1c485159a040f312fb9bac0ed6195b5a11d0519ac42081997619b64a0858c(
+    *,
+    availability_zone: builtins.str,
+    ipv4_cidr_block: builtins.str,
+    subnet_id: builtins.str,
+    subnet_type: _aws_cdk_aws_ec2_ceddda9d.SubnetType,
+    ipv6_cidr_block: typing.Optional[builtins.str] = None,
+    route_table_id: typing.Optional[builtins.str] = None,
+    subnet_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__95ce99f8025433ac8b79825abef6ff91da4dfd0693fd24dadedcee63eb93d668(
     *,
     availability_zone: builtins.str,
@@ -6347,6 +7377,20 @@ def _typecheckingstub__95ce99f8025433ac8b79825abef6ff91da4dfd0693fd24dadedcee63e
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4302f03d1c3aa687fb9a6d3011f239c94d844badf36d9d2e8270a543f80a5d49(
+    *,
+    amazon_provided_ipv6_cidr_block: typing.Optional[builtins.bool] = None,
+    cidr_block: typing.Optional[builtins.str] = None,
+    cidr_block_name: typing.Optional[builtins.str] = None,
+    ipv4_ipam_pool_id: typing.Optional[builtins.str] = None,
+    ipv4_ipam_provisioned_cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ipv4_netmask_length: typing.Optional[jsii.Number] = 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__99ebb03388deee94929850a6302ea70455c70b08fdbc048c0ad431df4f5d7bff(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -6388,6 +7432,7 @@ def _typecheckingstub__dc5a774224468f268ba34d837f3aec361583306c8694ae77cdb19bb4c
     dependencies: typing.Optional[typing.Sequence[_aws_cdk_ceddda9d.CfnResource]] = None,
     ipv4_cidr_block: typing.Optional[builtins.str] = None,
     ipv4_ipam_pool: typing.Optional[IIpamPool] = None,
+    ipv4_ipam_provisioned_cidrs: typing.Optional[typing.Sequence[builtins.str]] = None,
     ipv4_netmask_length: typing.Optional[jsii.Number] = None,
     ipv6_ipam_pool: typing.Optional[IIpamPool] = None,
     ipv6_netmask_length: typing.Optional[jsii.Number] = None,
@@ -6395,6 +7440,19 @@ def _typecheckingstub__dc5a774224468f268ba34d837f3aec361583306c8694ae77cdb19bb4c
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__456e1aed5fd7b92e9fe1ffc4615970b62870dbb14e689177f2fdb104f3200b6b(
+    *,
+    vpc_cidr_block: builtins.str,
+    vpc_id: builtins.str,
+    owner_account_id: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
+    secondary_cidr_blocks: typing.Optional[typing.Sequence[typing.Union[VPCCidrBlockattributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetV2Attributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpn_gateway_id: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ff6eb90e3be796c2f978cd0f80c5571eb321f8dc6456107e14e0363d3dd777fb(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -6518,3 +7576,18 @@ def _typecheckingstub__43890f4b3ccf690abe4140abf07c3436fde6604bac35ff6b2e8fe5da2
 ) -> None:
     """Type checking stubs"""
     pass
+
+def _typecheckingstub__a44e5d77c989876de48b8f71adf0b240f0b6a3149cc8bd0c5ab7bb8df6f6791f(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    vpc_cidr_block: builtins.str,
+    vpc_id: builtins.str,
+    owner_account_id: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
+    secondary_cidr_blocks: typing.Optional[typing.Sequence[typing.Union[VPCCidrBlockattributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+    subnets: typing.Optional[typing.Sequence[typing.Union[SubnetV2Attributes, typing.Dict[builtins.str, typing.Any]]]] = None,
+    vpn_gateway_id: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass