terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/vpc.js

@@ -0,0 +1,1495 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateSubnet = exports.PublicSubnet = exports.RouterType = exports.Subnet = exports.Vpc = exports.DefaultInstanceTenancy = exports.SubnetType = exports.IpProtocol = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+// import { RestrictDefaultSgProvider } from "../../custom-resource-handlers/dist/aws-ec2/restrict-default-sg-provider.generated";
+const constructs_1 = require("constructs");
+const client_vpn_endpoint_1 = require("./client-vpn-endpoint");
+const ec2_util_1 = require("./ec2-util");
+const ip_addresses_1 = require("./ip-addresses");
+const nat_1 = require("./nat");
+const network_acl_1 = require("./network-acl");
+const subnet_1 = require("./subnet");
+const vpc_endpoint_1 = require("./vpc-endpoint");
+const vpc_flow_logs_1 = require("./vpc-flow-logs");
+// import { VpcLookupOptions } from "./vpc-lookup";
+const vpn_1 = require("./vpn");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const VPC_SUBNET_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.VpcSubnet");
+const FAKE_AZ_NAME = "fake-az";
+/**
+ * The types of IP addresses provisioned in the VPC.
+ */
+var IpProtocol;
+(function (IpProtocol) {
+    /**
+     * The vpc will be configured with only IPv4 addresses.
+     *
+     * This is the default protocol if unset.
+     */
+    IpProtocol["IPV4_ONLY"] = "Ipv4_Only";
+    /**
+     * 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.
+     */
+    IpProtocol["DUAL_STACK"] = "Dual_Stack";
+})(IpProtocol || (exports.IpProtocol = IpProtocol = {}));
+/**
+ * The type of Subnet
+ */
+var SubnetType;
+(function (SubnetType) {
+    /**
+     * 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.
+     */
+    SubnetType["PRIVATE_ISOLATED"] = "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.
+     *
+     * @deprecated use `SubnetType.PRIVATE_ISOLATED`
+     */
+    SubnetType["ISOLATED"] = "Deprecated_Isolated";
+    /**
+     * 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.
+     */
+    SubnetType["PRIVATE_WITH_EGRESS"] = "Private";
+    /**
+     * 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`
+     */
+    SubnetType["PRIVATE_WITH_NAT"] = "Deprecated_Private_NAT";
+    /**
+     * 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. 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`
+     */
+    SubnetType["PRIVATE"] = "Deprecated_Private";
+    /**
+     * 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.
+     */
+    SubnetType["PUBLIC"] = "Public";
+})(SubnetType || (exports.SubnetType = SubnetType = {}));
+/**
+ * A new or imported VPC
+ */
+class VpcBase extends aws_construct_1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Dependencies for NAT connectivity
+         *
+         * @deprecated - This value is no longer used.
+         */
+        this.natDependencies = new Array();
+        /**
+         * If this is set to true, don't error out on trying to select subnets
+         */
+        this.incompleteSubnetDefinition = false;
+    }
+    get vpcOutputs() {
+        return {
+            availabilityZones: this.availabilityZones,
+            isolatedSubnetIds: this.isolatedSubnets.map((s) => s.subnetId),
+            privateSubnetIds: this.privateSubnets.map((s) => s.subnetId),
+            publicSubnetIds: this.publicSubnets.map((s) => s.subnetId),
+            vpcArn: this.vpcArn,
+            vpcCidrBlock: this.vpcCidrBlock,
+            vpcId: this.vpcId,
+            vpnGatewayId: this.vpnGatewayId,
+        };
+    }
+    get outputs() {
+        return this.vpcOutputs;
+    }
+    /**
+     * Returns IDs of selected subnets
+     */
+    selectSubnets(selection = {}) {
+        const subnets = this.selectSubnetObjects(selection);
+        const pubs = new Set(this.publicSubnets);
+        return {
+            subnetIds: subnets.map((s) => s.subnetId),
+            get availabilityZones() {
+                return subnets.map((s) => s.availabilityZone);
+            },
+            internetConnectivityEstablished: tap(new CompositeDependable(), (d) => subnets.forEach((s) => d.add(s.internetConnectivityEstablished))),
+            subnets,
+            hasPublic: subnets.some((s) => pubs.has(s)),
+            isPendingLookup: this.incompleteSubnetDefinition,
+        };
+    }
+    /**
+     * Adds a VPN Gateway to this VPC
+     */
+    enableVpnGateway(options) {
+        if (this.vpnGatewayId) {
+            throw new Error("The VPN Gateway has already been enabled.");
+        }
+        const vpnGateway = new vpn_1.VpnGateway(this, "VpnGateway", {
+            amazonSideAsn: options.amazonSideAsn,
+            type: vpn_1.VpnConnectionType.IPSEC_1,
+        });
+        this._vpnGatewayId = vpnGateway.gatewayId;
+        const attachment = new provider_aws_1.vpnGatewayAttachment.VpnGatewayAttachment(this, "VPCVPNGW", {
+            vpcId: this.vpcId,
+            vpnGatewayId: this._vpnGatewayId,
+        });
+        // Propagate routes on route tables associated with the right subnets
+        const vpnRoutePropagation = options.vpnRoutePropagation ?? [{}];
+        const routeTableIds = (0, ec2_util_1.allRouteTableIds)((0, ec2_util_1.flatten)(vpnRoutePropagation.map((s) => this.selectSubnets(s).subnets)));
+        if (routeTableIds.length === 0) {
+            cdktf_1.Annotations.of(this).addError(`enableVpnGateway: no subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`);
+        }
+        for (let i = 0; i < routeTableIds.length; i++) {
+            const routePropagation = new provider_aws_1.vpnGatewayRoutePropagation.VpnGatewayRoutePropagation(this, `RoutePropagation${i}`, {
+                routeTableId: routeTableIds[i],
+                vpnGatewayId: this._vpnGatewayId,
+            });
+            // The aws_vpn_gateway_route_propagation resource cannot use the VPN gateway
+            // until it has successfully attached to the VPC.
+            // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html
+            routePropagation.node.addDependency(attachment);
+        }
+    }
+    /**
+     * Adds a new VPN connection to this VPC
+     */
+    addVpnConnection(id, options) {
+        return new vpn_1.VpnConnection(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+     * Adds a new client VPN endpoint to this VPC
+     */
+    addClientVpnEndpoint(id, options) {
+        return new client_vpn_endpoint_1.ClientVpnEndpoint(this, id, {
+            ...options,
+            vpc: this,
+        });
+    }
+    /**
+     * Adds a new interface endpoint to this VPC
+     */
+    addInterfaceEndpoint(id, options) {
+        return new vpc_endpoint_1.InterfaceVpcEndpoint(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+     * Adds a new gateway endpoint to this VPC
+     */
+    addGatewayEndpoint(id, options) {
+        return new vpc_endpoint_1.GatewayVpcEndpoint(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+     * Adds a new flow log to this VPC
+     */
+    addFlowLog(id, options) {
+        return new vpc_flow_logs_1.FlowLog(this, id, {
+            resourceType: vpc_flow_logs_1.FlowLogResourceType.fromVpc(this),
+            ...options,
+        });
+    }
+    /**
+     * Returns the id of the VPN Gateway (if enabled)
+     */
+    get vpnGatewayId() {
+        return this._vpnGatewayId;
+    }
+    /**
+     * Return the subnets appropriate for the placement strategy
+     */
+    selectSubnetObjects(selection = {}) {
+        selection = this.reifySelectionDefaults(selection);
+        if (selection.subnets !== undefined) {
+            return selection.subnets;
+        }
+        let subnets;
+        if (selection.subnetGroupName !== undefined) {
+            // Select by name
+            subnets = this.selectSubnetObjectsByName(selection.subnetGroupName);
+        }
+        else {
+            // Or specify by type
+            const type = selection.subnetType || SubnetType.PRIVATE_WITH_EGRESS;
+            subnets = this.selectSubnetObjectsByType(type);
+        }
+        // Apply all the filters
+        subnets = this.applySubnetFilters(subnets, selection.subnetFilters ?? []);
+        return subnets;
+    }
+    applySubnetFilters(subnets, filters) {
+        let filtered = subnets;
+        // Apply each filter in sequence
+        for (const filter of filters) {
+            filtered = filter.selectSubnets(filtered);
+        }
+        return filtered;
+    }
+    selectSubnetObjectsByName(groupName) {
+        const allSubnets = [
+            ...this.publicSubnets,
+            ...this.privateSubnets,
+            ...this.isolatedSubnets,
+        ];
+        const subnets = allSubnets.filter((s) => (0, ec2_util_1.subnetGroupNameFromConstructId)(s) === groupName);
+        if (subnets.length === 0 && !this.incompleteSubnetDefinition) {
+            const names = Array.from(new Set(allSubnets.map(ec2_util_1.subnetGroupNameFromConstructId)));
+            throw new Error(`There are no subnet groups with name '${groupName}' in this VPC. Available names: ${names}`);
+        }
+        return subnets;
+    }
+    selectSubnetObjectsByType(subnetType) {
+        const allSubnets = {
+            [SubnetType.PRIVATE_ISOLATED]: this.isolatedSubnets,
+            [SubnetType.ISOLATED]: this.isolatedSubnets,
+            [SubnetType.PRIVATE_WITH_NAT]: this.privateSubnets,
+            [SubnetType.PRIVATE_WITH_EGRESS]: this.privateSubnets,
+            [SubnetType.PRIVATE]: this.privateSubnets,
+            [SubnetType.PUBLIC]: this.publicSubnets,
+        };
+        const subnets = allSubnets[subnetType];
+        // Force merge conflict here with https://github.com/aws/aws-cdk/pull/4089
+        // see ImportedVpc
+        if (subnets.length === 0 && !this.incompleteSubnetDefinition) {
+            const availableTypes = Object.entries(allSubnets)
+                .filter(([_, subs]) => subs.length > 0)
+                .map(([typeName, _]) => typeName);
+            throw new Error(`There are no '${subnetType}' subnet groups in this VPC. Available types: ${availableTypes}`);
+        }
+        return subnets;
+    }
+    /**
+     * Validate the fields in a SubnetSelection object, and reify defaults if necessary
+     *
+     * In case of default selection, select the first type of PRIVATE, ISOLATED,
+     * PUBLIC (in that order) that has any subnets.
+     */
+    reifySelectionDefaults(placement) {
+        if (placement.subnetName !== undefined) {
+            if (placement.subnetGroupName !== undefined) {
+                throw new Error("Please use only 'subnetGroupName' ('subnetName' is deprecated and has the same behavior)");
+            }
+            else {
+                // "@aws-cdk/aws-ec2:subnetNameDeprecated",
+                cdktf_1.Annotations.of(this).addWarning("Usage of 'subnetName' in SubnetSelection is deprecated, use 'subnetGroupName' instead");
+            }
+            placement = { ...placement, subnetGroupName: placement.subnetName };
+        }
+        const exclusiveSelections = [
+            "subnets",
+            "subnetType",
+            "subnetGroupName",
+        ];
+        const providedSelections = exclusiveSelections.filter((key) => placement[key] !== undefined);
+        if (providedSelections.length > 1) {
+            throw new Error(`Only one of '${providedSelections}' can be supplied to subnet selection.`);
+        }
+        if (placement.subnetType === undefined &&
+            placement.subnetGroupName === undefined &&
+            placement.subnets === undefined) {
+            // Return default subnet type based on subnets that actually exist
+            let subnetType = this.privateSubnets.length
+                ? SubnetType.PRIVATE_WITH_EGRESS
+                : this.isolatedSubnets.length
+                    ? SubnetType.PRIVATE_ISOLATED
+                    : SubnetType.PUBLIC;
+            placement = { ...placement, subnetType: subnetType };
+        }
+        // Establish which subnet filters are going to be used
+        let subnetFilters = placement.subnetFilters ?? [];
+        // Backwards compatibility with existing `availabilityZones` and `onePerAz` functionality
+        if (placement.availabilityZones !== undefined) {
+            // Filter by AZs, if specified
+            subnetFilters.push(subnet_1.SubnetFilter.availabilityZones(placement.availabilityZones));
+        }
+        if (!!placement.onePerAz) {
+            // Ensure one per AZ if specified
+            subnetFilters.push(subnet_1.SubnetFilter.onePerAz());
+        }
+        // Overwrite the provided placement filters and remove the availabilityZones and onePerAz properties
+        placement = {
+            ...placement,
+            subnetFilters: subnetFilters,
+            availabilityZones: undefined,
+            onePerAz: undefined,
+        };
+        const { availabilityZones, onePerAz, ...rest } = placement;
+        return rest;
+    }
+}
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * The default tenancy of instances launched into the VPC.
+ */
+var DefaultInstanceTenancy;
+(function (DefaultInstanceTenancy) {
+    /**
+     * Instances can be launched with any tenancy.
+     */
+    DefaultInstanceTenancy["DEFAULT"] = "default";
+    /**
+     * Any instance launched into the VPC automatically has dedicated tenancy, unless you launch it with the default tenancy.
+     */
+    DefaultInstanceTenancy["DEDICATED"] = "dedicated";
+})(DefaultInstanceTenancy || (exports.DefaultInstanceTenancy = DefaultInstanceTenancy = {}));
+/**
+ * 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:
+ *
+ * ```ts
+ * const vpc = new compute.Vpc(this, 'TheVPC', {
+ *   ipAddresses: compute.IpAddresses.cidr('10.0.0.0/16'),
+ * })
+ *
+ * // Iterate the private subnets
+ * const selection = vpc.selectSubnets({
+ *   subnetType: compute.SubnetType.PRIVATE_WITH_EGRESS
+ * });
+ *
+ * for (const subnet of selection.subnets) {
+ *   // ...
+ * }
+ * ```
+ *
+ * @resource aws_vpc
+ */
+class Vpc extends VpcBase {
+    /**
+     * Import a VPC by supplying all attributes directly
+     *
+     * NOTE: using `fromVpcAttributes()` with deploy-time parameters (like a `TerraformVariable`
+     * 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.
+     */
+    static fromVpcAttributes(
+    // TODO: Prefer to use `Vpc.fromLookup()` instead.
+    scope, id, attrs) {
+        return new ImportedVpc(scope, id, attrs, false);
+    }
+    /**
+     * 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).
+     */
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        /**
+         * List of public subnets in this VPC
+         */
+        this.publicSubnets = [];
+        /**
+         * List of private subnets in this VPC
+         */
+        this.privateSubnets = [];
+        /**
+         * List of isolated subnets in this VPC
+         */
+        this.isolatedSubnets = [];
+        /**
+         * Subnet configurations for this VPC
+         */
+        this.subnetConfiguration = [];
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        const stack = this.stack;
+        // Can't have enabledDnsHostnames without enableDnsSupport
+        if (props.enableDnsHostnames && !props.enableDnsSupport) {
+            throw new Error("To use DNS Hostnames, DNS Support must be enabled, however, it was explicitly disabled.");
+        }
+        if (props.availabilityZones && props.maxAzs) {
+            throw new Error("Vpc supports 'availabilityZones' or 'maxAzs', but not both.");
+        }
+        const cidrBlock = ifUndefined(props.cidr, Vpc.DEFAULT_CIDR_RANGE);
+        if (cdktf_1.Token.isUnresolved(cidrBlock)) {
+            throw new Error("'cidr' property must be a concrete CIDR string, got a Token (we need to parse it for automatic subdivision)");
+        }
+        if (props.ipAddresses && props.cidr) {
+            throw new Error("supply at most one of ipAddresses or cidr");
+        }
+        const ipProtocol = props.ipProtocol ?? IpProtocol.IPV4_ONLY;
+        // this property can be set to false if an IPv6_ONLY VPC is implemented in the future
+        this.useIpv4 =
+            ipProtocol === IpProtocol.IPV4_ONLY ||
+                ipProtocol === IpProtocol.DUAL_STACK;
+        this.useIpv6 = ipProtocol === IpProtocol.DUAL_STACK;
+        const ipv6OnlyProps = ["ipv6Addresses"];
+        if (!this.useIpv6) {
+            for (const prop of ipv6OnlyProps) {
+                if (props[prop] !== undefined) {
+                    throw new Error(`${prop} can only be set if IPv6 is enabled. Set ipProtocol to DUAL_STACK`);
+                }
+            }
+        }
+        this.ipAddresses = props.ipAddresses ?? ip_addresses_1.IpAddresses.cidr(cidrBlock);
+        this.dnsHostnamesEnabled =
+            props.enableDnsHostnames == null ? true : props.enableDnsHostnames;
+        this.dnsSupportEnabled =
+            props.enableDnsSupport == null ? true : props.enableDnsSupport;
+        const instanceTenancy = props.defaultInstanceTenancy || "default";
+        this.internetConnectivityEstablished =
+            this._internetConnectivityEstablished;
+        const vpcIpAddressOptions = this.ipAddresses.allocateVpcCidr();
+        // Define a VPC using the provided CIDR range
+        this.resource = new provider_aws_1.vpc.Vpc(this, "Resource", {
+            cidrBlock: vpcIpAddressOptions.cidrBlock,
+            ipv4IpamPoolId: vpcIpAddressOptions.ipv4IpamPoolId,
+            ipv4NetmaskLength: vpcIpAddressOptions.ipv4NetmaskLength,
+            enableDnsHostnames: this.dnsHostnamesEnabled,
+            enableDnsSupport: this.dnsSupportEnabled,
+            instanceTenancy,
+        });
+        this.vpcDefaultNetworkAcl = this.resource.defaultNetworkAclId;
+        this.vpcCidrBlock = this.resource.cidrBlock;
+        this.vpcDefaultSecurityGroup = this.resource.defaultSecurityGroupId;
+        this.vpcIpv6CidrBlock = this.resource.ipv6CidrBlock;
+        // this.vpcCidrBlockAssociations = this.resource.cidrBlockAssociations;
+        aws_tags_1.Tags.of(this).add(NAME_TAG, props.vpcName || this.node.path);
+        if (props.availabilityZones) {
+            // TODO: Implement ContextProvider to validate AZs
+            // // If given AZs and stack AZs are both resolved, then validate their compatibility.
+            // const resolvedStackAzs = this.resolveStackAvailabilityZones(
+            //   stack.availabilityZones(props.maxAzs),
+            // );
+            // const areGivenAzsSubsetOfStack =
+            //   resolvedStackAzs.length === 0 ||
+            //   props.availabilityZones.every(
+            //     (az) => Token.isUnresolved(az) || resolvedStackAzs.includes(az),
+            //   );
+            // if (!areGivenAzsSubsetOfStack) {
+            //   throw new Error(
+            //     `Given VPC 'availabilityZones' ${props.availabilityZones} must be a subset of the stack's availability zones ${resolvedStackAzs}`,
+            //   );
+            // }
+            this.availabilityZones = props.availabilityZones;
+        }
+        else {
+            const maxAZs = props.maxAzs ?? 3;
+            this.availabilityZones = stack.availabilityZones(maxAZs);
+        }
+        for (let i = 0; props.reservedAzs && i < props.reservedAzs; i++) {
+            this.availabilityZones.push(FAKE_AZ_NAME);
+        }
+        this.vpcId = this.resource.id;
+        this.vpcArn = arn_1.Arn.format({
+            service: "ec2",
+            resource: "vpc",
+            resourceName: this.vpcId,
+        }, stack);
+        const defaultSubnet = props.natGateways === 0
+            ? Vpc.DEFAULT_SUBNETS_NO_NAT
+            : Vpc.DEFAULT_SUBNETS;
+        this.subnetConfiguration = ifUndefined(props.subnetConfiguration, defaultSubnet);
+        const natGatewayPlacement = props.natGatewaySubnets || {
+            subnetType: SubnetType.PUBLIC,
+        };
+        const natGatewayCount = determineNatGatewayCount(props.natGateways, this.subnetConfiguration, this.availabilityZones.length);
+        if (this.useIpv6) {
+            this.ipv6Addresses =
+                props.ipv6Addresses ?? ip_addresses_1.Ipv6Addresses.amazonProvided();
+            this.ipv6CidrBlock = this.ipv6Addresses.allocateVpcIpv6Cidr({
+                scope: this,
+                vpcId: this.vpcId,
+            });
+            // TODO: how to allow ipv6 cidr block inputs?
+            this.ipv6SelectedCidr = this.resource.ipv6CidrBlock;
+        }
+        // subnetConfiguration must be set before calling createSubnets
+        this.createSubnets();
+        const createInternetGateway = props.createInternetGateway ?? true;
+        const allowOutbound = this.subnetConfiguration.filter((sn) => sn.subnetType !== SubnetType.PRIVATE_ISOLATED &&
+            sn.subnetType !== SubnetType.ISOLATED &&
+            !sn.reserved).length > 0;
+        // Create an Internet Gateway and attach it if necessary
+        if (allowOutbound && createInternetGateway) {
+            const igw = new provider_aws_1.internetGateway.InternetGateway(this, "IGW", {});
+            this.internetGatewayId = igw.id;
+            this._internetConnectivityEstablished.add(igw);
+            const att = new provider_aws_1.internetGatewayAttachment.InternetGatewayAttachment(this, "VPCGW", {
+                internetGatewayId: igw.id,
+                vpcId: this.resource.id,
+            });
+            this.publicSubnets.forEach((publicSubnet) => {
+                // configure IPv4 route
+                if (this.useIpv4) {
+                    publicSubnet.addDefaultInternetRoute(igw.id, att);
+                }
+                // configure IPv6 route if VPC is dual stack
+                if (this.useIpv6) {
+                    publicSubnet.addIpv6DefaultInternetRoute(igw.id);
+                }
+            });
+            // if gateways are needed create them
+            if (natGatewayCount > 0) {
+                const provider = props.natGatewayProvider || nat_1.NatProvider.gateway();
+                this.createNatGateways(provider, natGatewayCount, natGatewayPlacement);
+            }
+        }
+        // Create an Egress Only Internet Gateway and attach it if necessary
+        if (this.useIpv6 && this.privateSubnets) {
+            const eigw = new provider_aws_1.egressOnlyInternetGateway.EgressOnlyInternetGateway(this, "EIGW6", {
+                vpcId: this.vpcId,
+            });
+            this.privateSubnets.forEach((privateSubnet) => {
+                privateSubnet.addIpv6DefaultEgressOnlyInternetRoute(eigw.id);
+            });
+        }
+        if (props.vpnGateway &&
+            this.publicSubnets.length === 0 &&
+            this.privateSubnets.length === 0 &&
+            this.isolatedSubnets.length === 0) {
+            throw new Error("Can not enable the VPN gateway while the VPC has no subnets at all");
+        }
+        if ((props.vpnConnections || props.vpnGatewayAsn) &&
+            props.vpnGateway === false) {
+            throw new Error("Cannot specify `vpnConnections` or `vpnGatewayAsn` when `vpnGateway` is set to false.");
+        }
+        if (props.vpnGateway || props.vpnConnections || props.vpnGatewayAsn) {
+            this.enableVpnGateway({
+                amazonSideAsn: props.vpnGatewayAsn,
+                type: vpn_1.VpnConnectionType.IPSEC_1,
+                vpnRoutePropagation: props.vpnRoutePropagation,
+            });
+            const vpnConnections = props.vpnConnections || {};
+            for (const [connectionId, connection] of Object.entries(vpnConnections)) {
+                this.addVpnConnection(connectionId, connection);
+            }
+        }
+        // Allow creation of gateway endpoints on VPC instantiation as those can be
+        // immediately functional without further configuration. This is not the case
+        // for interface endpoints where the security group must be configured.
+        if (props.gatewayEndpoints) {
+            const gatewayEndpoints = props.gatewayEndpoints || {};
+            for (const [endpointId, endpoint] of Object.entries(gatewayEndpoints)) {
+                this.addGatewayEndpoint(endpointId, endpoint);
+            }
+        }
+        // Add flow logs to the VPC
+        if (props.flowLogs) {
+            const flowLogs = props.flowLogs || {};
+            for (const [flowLogId, flowLog] of Object.entries(flowLogs)) {
+                this.addFlowLog(flowLogId, flowLog);
+            }
+        }
+        /**
+         * Enable this feature flag to remove the default ingress/egress rules from the
+         * VPC default security group.
+         *
+         * When a VPC is created, a default security group is created as well and this cannot
+         * be deleted. The default security group is created with ingress/egress rules that allow
+         * _all_ traffic. [AWS Security best practices recommend](https://docs.aws.amazon.com/securityhub/latest/userguide/ec2-controls.html#ec2-2)
+         * removing these ingress/egress rules in order to restrict access to the default security group.
+         */
+        // const restrictFlag = FeatureFlags.of(this).isEnabled(
+        //   EC2_RESTRICT_DEFAULT_SECURITY_GROUP,
+        // );
+        // if (
+        //   (restrictFlag && props.restrictDefaultSecurityGroup !== false) ||
+        //   props.restrictDefaultSecurityGroup
+        // ) {
+        //   this.restrictDefaultSecurityGroup();
+        // }
+    }
+    /**
+     * Adds a new S3 gateway endpoint to this VPC
+     *
+     * @deprecated use `addGatewayEndpoint()` instead
+     */
+    addS3Endpoint(id, subnets) {
+        return new vpc_endpoint_1.GatewayVpcEndpoint(this, id, {
+            service: vpc_endpoint_1.GatewayVpcEndpointAwsService.S3,
+            vpc: this,
+            subnets,
+        });
+    }
+    /**
+     * Adds a new DynamoDB gateway endpoint to this VPC
+     *
+     * @deprecated use `addGatewayEndpoint()` instead
+     */
+    addDynamoDbEndpoint(id, subnets) {
+        return new vpc_endpoint_1.GatewayVpcEndpoint(this, id, {
+            service: vpc_endpoint_1.GatewayVpcEndpointAwsService.DYNAMODB,
+            vpc: this,
+            subnets,
+        });
+    }
+    createNatGateways(provider, natCount, placement) {
+        const natSubnets = this.selectSubnetObjects(placement);
+        for (const sub of natSubnets) {
+            if (this.publicSubnets.indexOf(sub) === -1) {
+                throw new Error(`natGatewayPlacement ${placement} contains non public subnet ${sub}`);
+            }
+        }
+        provider.configureNat({
+            vpc: this,
+            natSubnets: natSubnets.slice(0, natCount),
+            privateSubnets: this.privateSubnets,
+        });
+    }
+    /**
+     * createSubnets creates the subnets specified by the subnet configuration
+     * array or creates the `DEFAULT_SUBNETS` configuration
+     */
+    createSubnets() {
+        const requestedSubnets = [];
+        this.subnetConfiguration.forEach((configuration) => this.availabilityZones.forEach((az, index) => {
+            requestedSubnets.push({
+                availabilityZone: az,
+                subnetConstructId: (0, ec2_util_1.subnetId)(configuration.name, index),
+                configuration,
+            });
+        }));
+        let { allocatedSubnets } = this.ipAddresses.allocateSubnetsCidr({
+            vpcCidr: this.vpcCidrBlock,
+            requestedSubnets,
+        });
+        if (allocatedSubnets.length != requestedSubnets.length) {
+            throw new Error("Incomplete Subnet Allocation; response array dose not equal input array");
+        }
+        if (this.useIpv6) {
+            if (this.ipv6SelectedCidr === undefined) {
+                throw new Error("No IPv6 CIDR block associated with this VPC could be found");
+            }
+            if (this.ipv6Addresses === undefined) {
+                throw new Error("No IPv6 IpAddresses were found");
+            }
+            // create the IPv6 CIDR blocks
+            const subnetIpv6Cidrs = this.ipv6Addresses.createIpv6CidrBlocks({
+                ipv6SelectedCidr: this.ipv6SelectedCidr,
+                subnetCount: allocatedSubnets.length,
+            });
+            // copy the list of allocated subnets while assigning the IPv6 CIDR
+            const allocatedSubnetsIpv6 = this.ipv6Addresses.allocateSubnetsIpv6Cidr({
+                allocatedSubnets: allocatedSubnets,
+                ipv6Cidrs: subnetIpv6Cidrs,
+            });
+            // assign allocated subnets to list with IPv6 addresses
+            allocatedSubnets = allocatedSubnetsIpv6.allocatedSubnets;
+        }
+        this.createSubnetResources(requestedSubnets, allocatedSubnets);
+        if (this.useIpv6) {
+            // add dependencies
+            this.publicSubnets.forEach((publicSubnet) => {
+                if (this.ipv6CidrBlock !== undefined) {
+                    publicSubnet.node.addDependency(this.ipv6CidrBlock);
+                }
+            });
+            this.privateSubnets.forEach((privateSubnet) => {
+                if (this.ipv6CidrBlock !== undefined) {
+                    privateSubnet.node.addDependency(this.ipv6CidrBlock);
+                }
+            });
+            this.isolatedSubnets.forEach((isolatedSubnet) => {
+                if (this.ipv6CidrBlock !== undefined) {
+                    isolatedSubnet.node.addDependency(this.ipv6CidrBlock);
+                }
+            });
+        }
+    }
+    /**
+     * Defaults to true in Subnet.Public for IPV4_ONLY VPCs.
+     *
+     * Defaults to false in Subnet.Public for DUAL_STACK VPCs.
+     *
+     * Always defaults to false in non-public subnets and will error if set.
+     */
+    calculateMapPublicIpOnLaunch(subnetConfig) {
+        if (subnetConfig.subnetType === SubnetType.PUBLIC) {
+            return subnetConfig.mapPublicIpOnLaunch !== undefined
+                ? subnetConfig.mapPublicIpOnLaunch
+                : !this.useIpv6; // changes default based on protocol of vpc
+        }
+        else {
+            if (subnetConfig.mapPublicIpOnLaunch !== undefined) {
+                throw new Error(`${subnetConfig.subnetType} subnet cannot include mapPublicIpOnLaunch parameter`);
+            }
+            return false;
+        }
+    }
+    createSubnetResources(requestedSubnets, allocatedSubnets) {
+        allocatedSubnets.forEach((allocated, i) => {
+            const { configuration: subnetConfig, subnetConstructId, availabilityZone, } = requestedSubnets[i];
+            if (subnetConfig.reserved === true) {
+                // For reserved subnets, do not create any resources
+                return;
+            }
+            if (availabilityZone === FAKE_AZ_NAME) {
+                // For reserved azs, do not create any resources
+                return;
+            }
+            const ipv6OnlyProps = [
+                "ipv6AssignAddressOnCreation",
+            ];
+            if (!this.useIpv6) {
+                for (const prop of ipv6OnlyProps) {
+                    if (subnetConfig[prop] !== undefined) {
+                        throw new Error(`${prop} can only be set if IPv6 is enabled. Set ipProtocol to DUAL_STACK`);
+                    }
+                }
+            }
+            const subnetProps = {
+                availabilityZone,
+                vpcId: this.vpcId,
+                cidrBlock: allocated.cidr,
+                mapPublicIpOnLaunch: this.calculateMapPublicIpOnLaunch(subnetConfig),
+                ipv6CidrBlock: allocated.ipv6Cidr,
+                assignIpv6AddressOnCreation: this.useIpv6
+                    ? (subnetConfig.ipv6AssignAddressOnCreation ?? true)
+                    : undefined,
+            };
+            let sn;
+            switch (subnetConfig.subnetType) {
+                case SubnetType.PUBLIC:
+                    const publicSubnet = new PublicSubnet(this, subnetConstructId, subnetProps);
+                    this.publicSubnets.push(publicSubnet);
+                    sn = publicSubnet;
+                    break;
+                case SubnetType.PRIVATE_WITH_EGRESS:
+                case SubnetType.PRIVATE_WITH_NAT:
+                case SubnetType.PRIVATE:
+                    const privateSubnet = new PrivateSubnet(this, subnetConstructId, subnetProps);
+                    this.privateSubnets.push(privateSubnet);
+                    sn = privateSubnet;
+                    break;
+                case SubnetType.PRIVATE_ISOLATED:
+                case SubnetType.ISOLATED:
+                    const isolatedSubnet = new PrivateSubnet(this, subnetConstructId, subnetProps);
+                    this.isolatedSubnets.push(isolatedSubnet);
+                    sn = isolatedSubnet;
+                    break;
+                default:
+                    throw new Error(`Unrecognized subnet type: ${subnetConfig.subnetType}`);
+            }
+            // These values will be used to recover the config upon provider import
+            const includeResourceTypes = [provider_aws_1.subnet.Subnet.tfResourceType];
+            aws_tags_1.Tags.of(sn).add(SUBNETNAME_TAG, subnetConfig.name, {
+                includeResourceTypes,
+            });
+            aws_tags_1.Tags.of(sn).add(SUBNETTYPE_TAG, subnetTypeTagValue(subnetConfig.subnetType), { includeResourceTypes });
+        });
+    }
+}
+exports.Vpc = Vpc;
+_a = JSII_RTTI_SYMBOL_1;
+Vpc[_a] = { fqn: "terraconstructs.aws.compute.Vpc", version: "0.0.12" };
+/**
+ * The default CIDR range used when creating VPCs.
+ * This can be overridden using VpcProps when creating a VPCNetwork resource.
+ * e.g. new Vpc(this, { cidr: '192.168.0.0./16' })
+ *
+ * Note this is specific to the IPv4 CIDR.
+ */
+Vpc.DEFAULT_CIDR_RANGE = "10.0.0.0/16";
+/**
+ * The default subnet configuration
+ *
+ * 1 Public and 1 Private subnet per AZ evenly split
+ */
+Vpc.DEFAULT_SUBNETS = [
+    {
+        subnetType: SubnetType.PUBLIC,
+        name: (0, ec2_util_1.defaultSubnetName)(SubnetType.PUBLIC),
+    },
+    {
+        subnetType: SubnetType.PRIVATE_WITH_EGRESS,
+        name: (0, ec2_util_1.defaultSubnetName)(SubnetType.PRIVATE_WITH_EGRESS),
+    },
+];
+/**
+ * The default subnet configuration if natGateways specified to be 0
+ *
+ * 1 Public and 1 Isolated Subnet per AZ evenly split
+ */
+Vpc.DEFAULT_SUBNETS_NO_NAT = [
+    {
+        subnetType: SubnetType.PUBLIC,
+        name: (0, ec2_util_1.defaultSubnetName)(SubnetType.PUBLIC),
+    },
+    {
+        subnetType: SubnetType.PRIVATE_ISOLATED,
+        name: (0, ec2_util_1.defaultSubnetName)(SubnetType.PRIVATE_ISOLATED),
+    },
+];
+const SUBNETTYPE_TAG = "aws-cdk:subnet-type";
+const SUBNETNAME_TAG = "aws-cdk:subnet-name";
+function subnetTypeTagValue(type) {
+    switch (type) {
+        case SubnetType.PUBLIC:
+            return "Public";
+        case SubnetType.PRIVATE_WITH_EGRESS:
+        case SubnetType.PRIVATE_WITH_NAT:
+        case SubnetType.PRIVATE:
+            return "Private";
+        case SubnetType.PRIVATE_ISOLATED:
+        case SubnetType.ISOLATED:
+            return "Isolated";
+    }
+}
+/**
+ * Represents a new VPC subnet resource
+ *
+ * @resource aws_subnet
+ */
+class Subnet extends aws_construct_1.AwsConstructBase {
+    static isVpcSubnet(x) {
+        return VPC_SUBNET_SYMBOL in x;
+    }
+    static fromSubnetAttributes(scope, id, attrs) {
+        return new ImportedSubnet(scope, id, attrs);
+    }
+    /**
+     * Import existing subnet from id.
+     */
+    static fromSubnetId(scope, id, 
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    subnetId) {
+        return this.fromSubnetAttributes(scope, id, { subnetId });
+    }
+    get outputs() {
+        return this.subnetOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        /**
+         * Parts of this VPC subnet
+         */
+        this.dependencyElements = [];
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        Object.defineProperty(this, VPC_SUBNET_SYMBOL, { value: true });
+        aws_tags_1.Tags.of(this).add(NAME_TAG, this.node.path);
+        this.availabilityZone = props.availabilityZone;
+        this.ipv4CidrBlock = props.cidrBlock;
+        this.resource = new provider_aws_1.subnet.Subnet(this, "Resource", {
+            vpcId: props.vpcId,
+            cidrBlock: props.cidrBlock,
+            availabilityZone: props.availabilityZone,
+            mapPublicIpOnLaunch: props.mapPublicIpOnLaunch,
+            ipv6CidrBlock: props.ipv6CidrBlock,
+            assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation,
+        });
+        this.subnetId = this.resource.id;
+        this.subnetVpcId = this.resource.vpcId;
+        this.subnetAvailabilityZone = this.resource.availabilityZone;
+        // TODO: Support IPv6 Association blocks
+        this.subnetIpv6CidrBlock = this.resource.ipv6CidrBlock;
+        this.subnetOutpostArn = this.resource.outpostArn;
+        // Terraform subnet does not provide the default ACL NetworkAclAssociationId attribute
+        // // subnet.NetworkAclAssociationId is the default ACL after the subnet
+        // // was just created. However, the ACL can be replaced at a later time.
+        // this._networkAcl = NetworkAcl.fromNetworkAclId(
+        //   this,
+        //   "Acl",
+        //   this.resource.NetworkAclAssociationId,
+        // );
+        this.subnetNetworkAclAssociationId = cdktf_1.Lazy.stringValue({
+            produce: () => this._networkAcl?.networkAclId ?? cdktf_1.Token.asString(null),
+        });
+        const table = new provider_aws_1.routeTable.RouteTable(this, "RouteTable", {
+            vpcId: props.vpcId,
+        });
+        this.routeTable = { routeTableId: table.id };
+        // Associate the public route table for this subnet, to this subnet
+        const routeAssoc = new provider_aws_1.routeTableAssociation.RouteTableAssociation(this, "RouteTableAssociation", {
+            subnetId: this.subnetId,
+            routeTableId: table.id,
+        });
+        this._internetConnectivityEstablished.add(routeAssoc);
+        this.internetConnectivityEstablished =
+            this._internetConnectivityEstablished;
+        this.subnetOutputs = {
+            subnetId: this.subnetId,
+            ipv4CidrBlock: this.ipv4CidrBlock,
+            routeTableId: this.routeTable.routeTableId,
+        };
+    }
+    /**
+     * Create a default route that points to a passed IGW, with a dependency
+     * on the IGW's attachment to the VPC.
+     *
+     * @param gatewayId the logical ID (ref) of the gateway attached to your VPC
+     * @param gatewayAttachment the gateway attachment construct to be added as a dependency
+     */
+    addDefaultInternetRoute(gatewayId, gatewayAttachment) {
+        const r = new provider_aws_1.route.Route(this, "DefaultRoute", {
+            routeTableId: this.routeTable.routeTableId,
+            destinationCidrBlock: "0.0.0.0/0",
+            gatewayId,
+        });
+        r.node.addDependency(gatewayAttachment);
+        // Since the 'r' depends on the gateway attachment, just
+        // depending on the route is enough.
+        this._internetConnectivityEstablished.add(r);
+    }
+    /**
+     * Create a default IPv6 route that points to a passed IGW.
+     *
+     * @param gatewayId the logical ID (ref) of the gateway attached to your VPC
+     */
+    addIpv6DefaultInternetRoute(gatewayId) {
+        this.addRoute("DefaultRoute6", {
+            routerType: RouterType.GATEWAY,
+            routerId: gatewayId,
+            destinationIpv6CidrBlock: "::/0",
+            enablesInternetConnectivity: true,
+        });
+    }
+    /**
+     * Create a default IPv6 route that points to a passed EIGW.
+     *
+     * @param gatewayId the logical ID (ref) of the gateway attached to your VPC
+     */
+    addIpv6DefaultEgressOnlyInternetRoute(gatewayId) {
+        this.addRoute("DefaultRoute6", {
+            routerType: RouterType.EGRESS_ONLY_INTERNET_GATEWAY,
+            routerId: gatewayId,
+            destinationIpv6CidrBlock: "::/0",
+            enablesInternetConnectivity: true,
+        });
+    }
+    /**
+     * Network ACL associated with this Subnet
+     *
+     * Upon creation, this is undefined pointing to
+     * 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()`.
+     */
+    get networkAcl() {
+        return this._networkAcl;
+    }
+    /**
+     * Adds an entry to this subnets route table that points to the passed NATGatewayId
+     * @param natGatewayId The ID of the NAT gateway
+     */
+    addDefaultNatRoute(natGatewayId) {
+        this.addRoute("DefaultRoute", {
+            routerType: RouterType.NAT_GATEWAY,
+            routerId: natGatewayId,
+            enablesInternetConnectivity: true,
+        });
+    }
+    /**
+     * Adds an entry to this subnets route table that points to the passed NATGatewayId.
+     * Uses the known 64:ff9b::/96 prefix.
+     * @param natGatewayId The ID of the NAT gateway
+     */
+    addIpv6Nat64Route(natGatewayId) {
+        this.addRoute("Nat64", {
+            routerType: RouterType.NAT_GATEWAY,
+            routerId: natGatewayId,
+            enablesInternetConnectivity: true,
+            destinationIpv6CidrBlock: "64:ff9b::/96",
+        });
+    }
+    /**
+     * Adds an entry to this subnets route table
+     */
+    addRoute(id, options) {
+        if (options.destinationCidrBlock && options.destinationIpv6CidrBlock) {
+            throw new Error("Cannot specify both 'destinationCidrBlock' and 'destinationIpv6CidrBlock'");
+        }
+        const r = new provider_aws_1.route.Route(this, id, {
+            routeTableId: this.routeTable.routeTableId,
+            destinationCidrBlock: options.destinationCidrBlock ||
+                (options.destinationIpv6CidrBlock === undefined
+                    ? "0.0.0.0/0"
+                    : undefined),
+            destinationIpv6CidrBlock: options.destinationIpv6CidrBlock,
+            [routerTypeToPropName(options.routerType)]: options.routerId,
+        });
+        if (options.enablesInternetConnectivity) {
+            this._internetConnectivityEstablished.add(r);
+        }
+    }
+    associateNetworkAcl(id, networkAcl) {
+        this._networkAcl = networkAcl;
+        const scope = networkAcl instanceof constructs_1.Construct ? networkAcl : this;
+        const other = networkAcl instanceof constructs_1.Construct ? this : networkAcl;
+        new network_acl_1.SubnetNetworkAclAssociation(scope, id + aws_stack_1.AwsStack.uniqueId(other.node), {
+            networkAcl,
+            subnet: this,
+        });
+    }
+}
+exports.Subnet = Subnet;
+_b = JSII_RTTI_SYMBOL_1;
+Subnet[_b] = { fqn: "terraconstructs.aws.compute.Subnet", version: "0.0.12" };
+/**
+ * Type of router used in route
+ */
+var RouterType;
+(function (RouterType) {
+    /**
+     * Carrier gateway
+     */
+    RouterType["CARRIER_GATEWAY"] = "CarrierGateway";
+    /**
+     * Egress-only Internet Gateway
+     */
+    RouterType["EGRESS_ONLY_INTERNET_GATEWAY"] = "EgressOnlyInternetGateway";
+    /**
+     * Internet Gateway
+     */
+    RouterType["GATEWAY"] = "Gateway";
+    // /**
+    //  * Instance
+    //  */
+    // INSTANCE = "Instance",
+    /**
+     * Local Gateway
+     */
+    RouterType["LOCAL_GATEWAY"] = "LocalGateway";
+    /**
+     * NAT Gateway
+     */
+    RouterType["NAT_GATEWAY"] = "NatGateway";
+    /**
+     * Network Interface
+     */
+    RouterType["NETWORK_INTERFACE"] = "NetworkInterface";
+    /**
+     * Transit Gateway
+     */
+    RouterType["TRANSIT_GATEWAY"] = "TransitGateway";
+    /**
+     * VPC peering connection
+     */
+    RouterType["VPC_PEERING_CONNECTION"] = "VpcPeeringConnection";
+    /**
+     * VPC Endpoint for gateway load balancers
+     */
+    RouterType["VPC_ENDPOINT"] = "VpcEndpoint";
+})(RouterType || (exports.RouterType = RouterType = {}));
+/**
+ * inverse of
+ * https://github.com/hashicorp/terraform-provider-aws/blob/v5.87.0/internal/service/ec2/vpc_route.go#L219-L239
+ */
+function routerTypeToPropName(routerType) {
+    const lookupMap = {
+        [RouterType.CARRIER_GATEWAY]: "carrierGatewayId",
+        [RouterType.EGRESS_ONLY_INTERNET_GATEWAY]: "egressOnlyGatewayId",
+        [RouterType.GATEWAY]: "gatewayId",
+        // terraform-provider-aws is missing switch case for InstanceId
+        // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateRoute.html
+        // [RouterType.INSTANCE]: "instanceId",
+        [RouterType.LOCAL_GATEWAY]: "localGatewayId",
+        [RouterType.NAT_GATEWAY]: "natGatewayId",
+        [RouterType.NETWORK_INTERFACE]: "networkInterfaceId",
+        [RouterType.TRANSIT_GATEWAY]: "transitGatewayId",
+        [RouterType.VPC_PEERING_CONNECTION]: "vpcPeeringConnectionId",
+        [RouterType.VPC_ENDPOINT]: "vpcEndpointId",
+    };
+    return lookupMap[routerType];
+}
+/**
+ * Represents a public VPC subnet resource
+ */
+class PublicSubnet extends Subnet {
+    static fromPublicSubnetAttributes(scope, id, attrs) {
+        return new ImportedSubnet(scope, id, attrs);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+    }
+    /**
+     * Creates a new managed NAT gateway attached to this public subnet.
+     * Also adds the EIP for the managed NAT.
+     * @returns A ref to the the NAT Gateway ID
+     */
+    addNatGateway(eipAllocationId) {
+        // Create a NAT Gateway in this public subnet
+        const ngw = new provider_aws_1.natGateway.NatGateway(this, "NATGateway", {
+            subnetId: this.subnetId,
+            allocationId: eipAllocationId ??
+                new provider_aws_1.eip.Eip(this, "EIP", {
+                    domain: "vpc",
+                }).allocationId,
+        });
+        ngw.node.addDependency(this.internetConnectivityEstablished);
+        return ngw;
+    }
+}
+exports.PublicSubnet = PublicSubnet;
+_c = JSII_RTTI_SYMBOL_1;
+PublicSubnet[_c] = { fqn: "terraconstructs.aws.compute.PublicSubnet", version: "0.0.12" };
+/**
+ * Represents a private VPC subnet resource
+ */
+class PrivateSubnet extends Subnet {
+    static fromPrivateSubnetAttributes(scope, id, attrs) {
+        return new ImportedSubnet(scope, id, attrs);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+    }
+}
+exports.PrivateSubnet = PrivateSubnet;
+_d = JSII_RTTI_SYMBOL_1;
+PrivateSubnet[_d] = { fqn: "terraconstructs.aws.compute.PrivateSubnet", version: "0.0.12" };
+function ifUndefined(value, defaultValue) {
+    return value ?? defaultValue;
+}
+class ImportedVpc extends VpcBase {
+    constructor(scope, id, props, isIncomplete) {
+        super(scope, id, {
+            region: props.region,
+        });
+        this.internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        this.vpcId = props.vpcId;
+        this.vpcArn = arn_1.Arn.format({
+            service: "ec2",
+            resource: "vpc",
+            resourceName: this.vpcId,
+        }, aws_stack_1.AwsStack.ofAwsConstruct(this));
+        this.cidr = props.vpcCidrBlock;
+        this.availabilityZones = props.availabilityZones;
+        this._vpnGatewayId = props.vpnGatewayId;
+        this.incompleteSubnetDefinition = isIncomplete;
+        // None of the values may be unresolved list tokens
+        for (const k of Object.keys(props)) {
+            if (Array.isArray(props[k]) && cdktf_1.Token.isUnresolved(props[k])) {
+                // `@aws-cdk/aws-ec2:vpcAttributeIsListToken${k}`,
+                cdktf_1.Annotations.of(this).addWarning(`fromVpcAttributes: '${k}' is a list token: the imported VPC will not work with constructs that require a list of subnets at synthesis time. Use 'Vpc.fromLookup()' or 'Fn.importListValue' instead.`);
+            }
+        }
+        const pub = new ec2_util_1.ImportSubnetGroup(props.publicSubnetIds, props.publicSubnetNames, props.publicSubnetRouteTableIds, props.publicSubnetIpv4CidrBlocks, SubnetType.PUBLIC, this.availabilityZones, "publicSubnetIds", "publicSubnetNames", "publicSubnetRouteTableIds", "publicSubnetIpv4CidrBlocks");
+        const priv = new ec2_util_1.ImportSubnetGroup(props.privateSubnetIds, props.privateSubnetNames, props.privateSubnetRouteTableIds, props.privateSubnetIpv4CidrBlocks, SubnetType.PRIVATE_WITH_EGRESS, this.availabilityZones, "privateSubnetIds", "privateSubnetNames", "privateSubnetRouteTableIds", "privateSubnetIpv4CidrBlocks");
+        const iso = new ec2_util_1.ImportSubnetGroup(props.isolatedSubnetIds, props.isolatedSubnetNames, props.isolatedSubnetRouteTableIds, props.isolatedSubnetIpv4CidrBlocks, SubnetType.PRIVATE_ISOLATED, this.availabilityZones, "isolatedSubnetIds", "isolatedSubnetNames", "isolatedSubnetRouteTableIds", "isolatedSubnetIpv4CidrBlocks");
+        this.publicSubnets = pub.import(this);
+        this.privateSubnets = priv.import(this);
+        this.isolatedSubnets = iso.import(this);
+    }
+    get vpcCidrBlock() {
+        if (this.cidr === undefined) {
+            throw new Error("Cannot perform this operation: 'vpcCidrBlock' was not supplied when creating this VPC");
+        }
+        return this.cidr;
+    }
+}
+// class LookedUpVpc extends VpcBase {
+//   public readonly vpcId: string;
+//   public readonly vpcArn: string;
+//   public readonly internetConnectivityEstablished: IDependable =
+//     new DependencyGroup();
+//   public readonly availabilityZones: string[];
+//   public readonly publicSubnets: ISubnet[];
+//   public readonly privateSubnets: ISubnet[];
+//   public readonly isolatedSubnets: ISubnet[];
+//   private readonly cidr?: string | undefined;
+//   constructor(
+//     scope: Construct,
+//     id: string,
+//     props: cxapi.VpcContextResponse,
+//     isIncomplete: boolean,
+//   ) {
+//     super(scope, id, {
+//       region: props.region,
+//       account: props.ownerAccountId,
+//     });
+//     this.vpcId = props.vpcId;
+//     this.vpcArn = Arn.format(
+//       {
+//         service: "ec2",
+//         resource: "vpc",
+//         resourceName: this.vpcId,
+//         region: this.env.region,
+//         account: this.env.account,
+//       },
+//       AwsStack.ofAwsConstruct(this),
+//     );
+//     this.cidr = props.vpcCidrBlock;
+//     this._vpnGatewayId = props.vpnGatewayId;
+//     this.incompleteSubnetDefinition = isIncomplete;
+//     const subnetGroups = props.subnetGroups || [];
+//     const availabilityZones = Array.from(
+//       new Set<string>(
+//         flatMap(subnetGroups, (subnetGroup) => {
+//           return subnetGroup.subnets.map((subnet) => subnet.availabilityZone);
+//         }),
+//       ),
+//     );
+//     availabilityZones.sort((az1, az2) => az1.localeCompare(az2));
+//     this.availabilityZones = availabilityZones;
+//     this.publicSubnets = this.extractSubnetsOfType(
+//       subnetGroups,
+//       cxapi.VpcSubnetGroupType.PUBLIC,
+//     );
+//     this.privateSubnets = this.extractSubnetsOfType(
+//       subnetGroups,
+//       cxapi.VpcSubnetGroupType.PRIVATE,
+//     );
+//     this.isolatedSubnets = this.extractSubnetsOfType(
+//       subnetGroups,
+//       cxapi.VpcSubnetGroupType.ISOLATED,
+//     );
+//   }
+//   public get vpcCidrBlock(): string {
+//     if (this.cidr === undefined) {
+//       // Value might be cached from an old CLI version, so bumping the CX API protocol to
+//       // force the value to exist would not have helped.
+//       throw new Error(
+//         "Cannot perform this operation: 'vpcCidrBlock' was not found when looking up this VPC. Use a newer version of the CDK CLI and clear the old context value.",
+//       );
+//     }
+//     return this.cidr;
+//   }
+//   private extractSubnetsOfType(
+//     subnetGroups: cxapi.VpcSubnetGroup[],
+//     subnetGroupType: cxapi.VpcSubnetGroupType,
+//   ): ISubnet[] {
+//     return flatMap(
+//       subnetGroups.filter(
+//         (subnetGroup) => subnetGroup.type === subnetGroupType,
+//       ),
+//       (subnetGroup) => this.subnetGroupToSubnets(subnetGroup),
+//     );
+//   }
+//   private subnetGroupToSubnets(subnetGroup: cxapi.VpcSubnetGroup): ISubnet[] {
+//     const ret = new Array<ISubnet>();
+//     for (let i = 0; i < subnetGroup.subnets.length; i++) {
+//       const vpcSubnet = subnetGroup.subnets[i];
+//       ret.push(
+//         Subnet.fromSubnetAttributes(this, `${subnetGroup.name}Subnet${i + 1}`, {
+//           availabilityZone: vpcSubnet.availabilityZone,
+//           subnetId: vpcSubnet.subnetId,
+//           routeTableId: vpcSubnet.routeTableId,
+//           ipv4CidrBlock: vpcSubnet.cidr,
+//         }),
+//       );
+//     }
+//     return ret;
+//   }
+// }
+// function flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[] {
+//   const ret = new Array<U>();
+//   for (const x of xs) {
+//     ret.push(...fn(x));
+//   }
+//   return ret;
+// }
+class CompositeDependable {
+    constructor() {
+        this.dependables = new Array();
+        const self = this;
+        constructs_1.Dependable.implement(this, {
+            get dependencyRoots() {
+                const ret = new Array();
+                for (const dep of self.dependables) {
+                    ret.push(...constructs_1.Dependable.of(dep).dependencyRoots);
+                }
+                return ret;
+            },
+        });
+    }
+    /**
+     * Add a construct to the dependency roots
+     */
+    add(dep) {
+        this.dependables.push(dep);
+    }
+}
+/**
+ * Invoke a function on a value (for its side effect) and return the value
+ */
+function tap(x, fn) {
+    fn(x);
+    return x;
+}
+class ImportedSubnet extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return this.subnetOutputs;
+    }
+    constructor(scope, id, attrs) {
+        super(scope, id, {
+            outputName: attrs.outputName,
+            registerOutputs: attrs.registerOutputs,
+        });
+        this.internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        if (!attrs.routeTableId) {
+            // The following looks a little weird, but comes down to:
+            //
+            // * Is the subnetId itself unresolved ({ Ref: Subnet }); or
+            // * Was it the accidentally extracted first element of a list-encoded
+            //   token? ({ Fn::ImportValue: Subnets } => ['#{Token[1234]}'] =>
+            //   '#{Token[1234]}'
+            //
+            // There's no other API to test for the second case than to the string back into
+            // a list and see if the combination is Unresolved.
+            //
+            // In both cases we can't output the subnetId literally into the metadata (because it'll
+            // be useless). In the 2nd case even, if we output it to metadata, the `resolve()` call
+            // that gets done on the metadata will even `throw`, because the '#{Token}' value will
+            // occur in an illegal position (not in a list context).
+            const ref = cdktf_1.Token.isUnresolved(attrs.subnetId) ||
+                cdktf_1.Token.isUnresolved([attrs.subnetId])
+                ? `at '${constructs_1.Node.of(scope).path}/${id}'`
+                : `'${attrs.subnetId}'`;
+            // eslint-disable-next-line max-len
+            // "@aws-cdk/aws-ec2:noSubnetRouteTableId",
+            cdktf_1.Annotations.of(this).addWarning(`No routeTableId was provided to the subnet ${ref}. Attempting to read its .routeTable.routeTableId will return null/undefined. (More info: https://github.com/aws/aws-cdk/pull/3171)`);
+        }
+        const lookup = new provider_aws_1.dataAwsSubnet.DataAwsSubnet(this, "Resource", {
+            id: attrs.subnetId,
+        });
+        this._ipv4CidrBlock = attrs.ipv4CidrBlock; // ?? lookup.cidrBlock;
+        this._availabilityZone = attrs.availabilityZone; // ?? lookup.availabilityZone;
+        this.subnetId = attrs.subnetId;
+        this.routeTable = {
+            // Forcing routeTableId to pretend non-null to maintain backwards-compatibility. See https://github.com/aws/aws-cdk/pull/3171
+            routeTableId: attrs.routeTableId,
+        };
+        this.subnetOutputs = {
+            subnetId: this.subnetId,
+            routeTableId: this.routeTable.routeTableId,
+            ipv4CidrBlock: lookup.cidrBlock,
+        };
+    }
+    get availabilityZone() {
+        if (!this._availabilityZone) {
+            // eslint-disable-next-line max-len
+            throw new Error("You cannot reference a Subnet's availability zone if it was not supplied. Add the availabilityZone when importing using Subnet.fromSubnetAttributes()");
+        }
+        return this._availabilityZone;
+    }
+    get ipv4CidrBlock() {
+        if (!this._ipv4CidrBlock) {
+            // tslint:disable-next-line: max-line-length
+            throw new Error("You cannot reference an imported Subnet's IPv4 CIDR if it was not supplied. Add the ipv4CidrBlock when importing using Subnet.fromSubnetAttributes()");
+        }
+        return this._ipv4CidrBlock;
+    }
+    associateNetworkAcl(id, networkAcl) {
+        const scope = networkAcl instanceof constructs_1.Construct ? networkAcl : this;
+        const other = networkAcl instanceof constructs_1.Construct ? this : networkAcl;
+        new network_acl_1.SubnetNetworkAclAssociation(scope, id + aws_stack_1.AwsStack.uniqueId(other.node), {
+            networkAcl,
+            subnet: this,
+        });
+    }
+}
+/**
+ * Determine (and validate) the NAT gateway count w.r.t. the rest of the subnet configuration
+ *
+ * We have the following requirements:
+ *
+ * - NatGatewayCount = 0 ==> there are no private subnets
+ * - NatGatewayCount > 0 ==> there must be public subnets
+ *
+ * Do we want to require that there are private subnets if there are NatGateways?
+ * They seem pointless but I see no reason to prevent it.
+ */
+function determineNatGatewayCount(requestedCount, subnetConfig, azCount) {
+    const hasPrivateSubnets = subnetConfig.some((c) => (c.subnetType === SubnetType.PRIVATE_WITH_EGRESS ||
+        c.subnetType === SubnetType.PRIVATE ||
+        c.subnetType === SubnetType.PRIVATE_WITH_NAT) &&
+        !c.reserved);
+    const hasPublicSubnets = subnetConfig.some((c) => c.subnetType === SubnetType.PUBLIC && !c.reserved);
+    const hasCustomEgress = subnetConfig.some((c) => c.subnetType === SubnetType.PRIVATE_WITH_EGRESS);
+    const count = requestedCount !== undefined
+        ? Math.min(requestedCount, azCount)
+        : hasPrivateSubnets
+            ? azCount
+            : 0;
+    if (count === 0 && hasPrivateSubnets && !hasCustomEgress) {
+        // eslint-disable-next-line max-len
+        throw new Error("If you do not want NAT gateways (natGateways=0), make sure you don't configure any PRIVATE(_WITH_NAT) subnets in 'subnetConfiguration' (make them PUBLIC or ISOLATED instead)");
+    }
+    if (count > 0 && !hasPublicSubnets) {
+        // eslint-disable-next-line max-len
+        throw new Error(`If you configure PRIVATE subnets in 'subnetConfiguration', you must also configure PUBLIC subnets to put the NAT gateways into (got ${JSON.stringify(subnetConfig)}.`);
+    }
+    return count;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc.js","sourceRoot":"","sources":["../../../src/aws/compute/vpc.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc.ts\n\nimport {\n  eip,\n  egressOnlyInternetGateway,\n  internetGateway,\n  natGateway,\n  route,\n  routeTable,\n  subnet,\n  routeTableAssociation,\n  vpc,\n  // vpcIpv4CidrBlockAssociation,\n  vpcIpv6CidrBlockAssociation,\n  internetGatewayAttachment,\n  vpnGatewayAttachment,\n  vpnGatewayRoutePropagation,\n  dataAwsSubnet,\n} from \"@cdktf/provider-aws\";\nimport {\n  // ContextProvider,\n  // CustomResource,\n  // FeatureFlags,\n  Annotations,\n  Lazy,\n  Token,\n} from \"cdktf\";\n// import { RestrictDefaultSgProvider } from \"../../custom-resource-handlers/dist/aws-ec2/restrict-default-sg-provider.generated\";\nimport {\n  Construct,\n  Dependable,\n  DependencyGroup,\n  IConstruct,\n  IDependable,\n  Node,\n} from \"constructs\";\nimport {\n  ClientVpnEndpoint,\n  ClientVpnEndpointOptions,\n} from \"./client-vpn-endpoint\";\nimport {\n  allRouteTableIds,\n  defaultSubnetName,\n  flatten,\n  ImportSubnetGroup,\n  subnetGroupNameFromConstructId,\n  subnetId,\n} from \"./ec2-util\";\nimport {\n  AllocatedSubnet,\n  IIpAddresses,\n  RequestedSubnet,\n  IpAddresses,\n  IIpv6Addresses,\n  Ipv6Addresses,\n} from \"./ip-addresses\";\nimport { NatProvider } from \"./nat\";\nimport {\n  INetworkAcl,\n  // NetworkAcl,\n  SubnetNetworkAclAssociation,\n} from \"./network-acl\";\nimport { SubnetFilter } from \"./subnet\";\nimport {\n  GatewayVpcEndpoint,\n  GatewayVpcEndpointAwsService,\n  GatewayVpcEndpointOptions,\n  InterfaceVpcEndpoint,\n  InterfaceVpcEndpointOptions,\n} from \"./vpc-endpoint\";\nimport { FlowLog, FlowLogOptions, FlowLogResourceType } from \"./vpc-flow-logs\";\n// import { VpcLookupOptions } from \"./vpc-lookup\";\nimport {\n  EnableVpnGatewayOptions,\n  VpnConnection,\n  VpnConnectionOptions,\n  VpnConnectionType,\n  VpnGateway,\n} from \"./vpn\";\nimport { Arn } from \"../arn\";\nimport { AwsConstructBase, IAwsConstruct } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\n\nconst VPC_SUBNET_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.VpcSubnet\",\n);\nconst FAKE_AZ_NAME = \"fake-az\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface SubnetOutputs {\n  /**\n   * The subnetId for this particular subnet\n   * @attribute\n   */\n  readonly subnetId: string;\n  /**\n   * The IPv4 CIDR block for this subnet\n   */\n  readonly ipv4CidrBlock: string;\n  /**\n   * The route table for this subnet\n   * @attribute\n   */\n  readonly routeTableId: string;\n}\n\nexport interface ISubnet extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly subnetOutputs: SubnetOutputs;\n\n  /**\n   * The Availability Zone the subnet is located in\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The subnetId for this particular subnet\n   * @attribute\n   */\n  readonly subnetId: string;\n\n  /**\n   * Dependable that can be depended upon to force internet connectivity established on the VPC\n   */\n  readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * The IPv4 CIDR block for this subnet\n   */\n  readonly ipv4CidrBlock: string;\n\n  /**\n   * The route table for this subnet\n   */\n  readonly routeTable: IRouteTable;\n\n  /**\n   * Associate a Network ACL with this subnet\n   *\n   * @param acl The Network ACL to associate\n   */\n  associateNetworkAcl(id: string, acl: INetworkAcl): void;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface RouteTableOutputs {\n  /**\n   * The route table ID\n   * @attribute\n   */\n  readonly routeTableId: string;\n}\n\n/**\n * An abstract route table\n */\nexport interface IRouteTable {\n  /**\n   * Route table ID\n   */\n  readonly routeTableId: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface VpcOutputs {\n  /**\n   * Identifier for this VPC\n   * @attribute\n   */\n  readonly vpcId: string;\n\n  /**\n   * ARN for this VPC\n   * @attribute\n   */\n  readonly vpcArn: string;\n\n  /**\n   * CIDR range for this VPC\n   *\n   * @attribute\n   */\n  readonly vpcCidrBlock: string;\n\n  /**\n   * List of public subnets in this VPC\n   *\n   * @attribute\n   */\n  readonly publicSubnetIds: string[];\n\n  /**\n   * List of private subnets in this VPC\n   *\n   * @attribute\n   */\n  readonly privateSubnetIds: string[];\n\n  /**\n   * List of isolated subnets in this VPC\n   *\n   * @attribute\n   */\n  readonly isolatedSubnetIds: string[];\n\n  /**\n   * AZs for this VPC\n   *\n   * @attribute\n   */\n  readonly availabilityZones: string[];\n\n  /**\n   * Identifier for the VPN gateway\n   *\n   * @attribute\n   */\n  readonly vpnGatewayId?: string;\n}\n\nexport interface IVpc extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly vpcOutputs: VpcOutputs;\n\n  /**\n   * Identifier for this VPC\n   * @attribute\n   */\n  readonly vpcId: string;\n\n  /**\n   * ARN for this VPC\n   * @attribute\n   */\n  readonly vpcArn: string;\n\n  /**\n   * CIDR range for this VPC\n   *\n   * @attribute\n   */\n  readonly vpcCidrBlock: string;\n\n  /**\n   * List of public subnets in this VPC\n   */\n  readonly publicSubnets: ISubnet[];\n\n  /**\n   * List of private subnets in this VPC\n   */\n  readonly privateSubnets: ISubnet[];\n\n  /**\n   * List of isolated subnets in this VPC\n   */\n  readonly isolatedSubnets: ISubnet[];\n\n  /**\n   * AZs for this VPC\n   */\n  readonly availabilityZones: string[];\n\n  /**\n   * Identifier for the VPN gateway\n   */\n  readonly vpnGatewayId?: string;\n\n  /**\n   * Dependable that can be depended upon to force internet connectivity established on the VPC\n   */\n  readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * Return information on the subnets appropriate for the given selection strategy\n   *\n   * Requires that at least one subnet is matched, throws a descriptive\n   * error message otherwise.\n   */\n  selectSubnets(selection?: SubnetSelection): SelectedSubnets;\n\n  /**\n   * Adds a VPN Gateway to this VPC\n   */\n  enableVpnGateway(options: EnableVpnGatewayOptions): void;\n\n  /**\n   * Adds a new VPN connection to this VPC\n   */\n  addVpnConnection(id: string, options: VpnConnectionOptions): VpnConnection;\n\n  /**\n   * Adds a new client VPN endpoint to this VPC\n   */\n  addClientVpnEndpoint(\n    id: string,\n    options: ClientVpnEndpointOptions,\n  ): ClientVpnEndpoint;\n\n  /**\n   * Adds a new gateway endpoint to this VPC\n   */\n  addGatewayEndpoint(\n    id: string,\n    options: GatewayVpcEndpointOptions,\n  ): GatewayVpcEndpoint;\n\n  /**\n   * Adds a new interface endpoint to this VPC\n   */\n  addInterfaceEndpoint(\n    id: string,\n    options: InterfaceVpcEndpointOptions,\n  ): InterfaceVpcEndpoint;\n\n  /**\n   * Adds a new Flow Log to this VPC\n   */\n  addFlowLog(id: string, options?: FlowLogOptions): FlowLog;\n}\n\n/**\n * The types of IP addresses provisioned in the VPC.\n */\nexport enum IpProtocol {\n  /**\n   * The vpc will be configured with only IPv4 addresses.\n   *\n   * This is the default protocol if unset.\n   */\n  IPV4_ONLY = \"Ipv4_Only\",\n\n  /**\n   * The vpc will have both IPv4 and IPv6 addresses.\n   *\n   * Unless specified, public IPv4 addresses will not be auto assigned,\n   * an egress only internet gateway (EIGW) will be created and configured,\n   * and NATs and internet gateways (IGW) will be configured with IPv6 addresses.\n   */\n  DUAL_STACK = \"Dual_Stack\",\n}\n\n/**\n * The type of Subnet\n */\nexport enum SubnetType {\n  /**\n   * Isolated Subnets do not route traffic to the Internet (in this VPC),\n   * and as such, do not require NAT gateways.\n   *\n   * Isolated subnets can only connect to or be connected to from other\n   * instances in the same VPC. A default VPC configuration will not include\n   * isolated subnets.\n   *\n   * This can be good for subnets with RDS or Elasticache instances,\n   * or which route Internet traffic through a peer VPC.\n   */\n  PRIVATE_ISOLATED = \"Isolated\",\n\n  /**\n   * Isolated Subnets do not route traffic to the Internet (in this VPC),\n   * and as such, do not require NAT gateways.\n   *\n   * Isolated subnets can only connect to or be connected to from other\n   * instances in the same VPC. A default VPC configuration will not include\n   * isolated subnets.\n   *\n   * This can be good for subnets with RDS or Elasticache instances,\n   * or which route Internet traffic through a peer VPC.\n   *\n   * @deprecated use `SubnetType.PRIVATE_ISOLATED`\n   */\n  ISOLATED = \"Deprecated_Isolated\",\n\n  /**\n   * Subnet that routes to the internet, but not vice versa.\n   *\n   * Instances in a private subnet can connect to the Internet, but will not\n   * allow connections to be initiated from the Internet. Egress to the internet will\n   * need to be provided.\n   * NAT Gateway(s) are the default solution to providing this subnet type the ability to route Internet traffic.\n   * If a NAT Gateway is not required or desired, set `natGateways:0` or use\n   * `SubnetType.PRIVATE_ISOLATED` instead.\n   *\n   * By default, a NAT gateway is created in every public subnet for maximum availability.\n   * Be aware that you will be charged for NAT gateways.\n   *\n   * Normally a Private subnet will use a NAT gateway in the same AZ, but\n   * if `natGateways` is used to reduce the number of NAT gateways, a NAT\n   * gateway from another AZ will be used instead.\n   */\n  PRIVATE_WITH_EGRESS = \"Private\",\n\n  /**\n   * Subnet that routes to the internet (via a NAT gateway), but not vice versa.\n   *\n   * Instances in a private subnet can connect to the Internet, but will not\n   * allow connections to be initiated from the Internet. NAT Gateway(s) are\n   * required with this subnet type to route the Internet traffic through.\n   * If a NAT Gateway is not required or desired, use `SubnetType.PRIVATE_ISOLATED` instead.\n   *\n   * By default, a NAT gateway is created in every public subnet for maximum availability.\n   * Be aware that you will be charged for NAT gateways.\n   *\n   * Normally a Private subnet will use a NAT gateway in the same AZ, but\n   * if `natGateways` is used to reduce the number of NAT gateways, a NAT\n   * gateway from another AZ will be used instead.\n   * @deprecated use `PRIVATE_WITH_EGRESS`\n   */\n  PRIVATE_WITH_NAT = \"Deprecated_Private_NAT\",\n\n  /**\n   * Subnet that routes to the internet, but not vice versa.\n   *\n   * Instances in a private subnet can connect to the Internet, but will not\n   * allow connections to be initiated from the Internet. NAT Gateway(s) are\n   * required with this subnet type to route the Internet traffic through.\n   * If a NAT Gateway is not required or desired, use `SubnetType.PRIVATE_ISOLATED` instead.\n   *\n   * By default, a NAT gateway is created in every public subnet for maximum availability.\n   * Be aware that you will be charged for NAT gateways.\n   *\n   * Normally a Private subnet will use a NAT gateway in the same AZ, but\n   * if `natGateways` is used to reduce the number of NAT gateways, a NAT\n   * gateway from another AZ will be used instead.\n   *\n   * @deprecated use `PRIVATE_WITH_EGRESS`\n   */\n  PRIVATE = \"Deprecated_Private\",\n\n  /**\n   * Subnet connected to the Internet\n   *\n   * Instances in a Public subnet can connect to the Internet and can be\n   * connected to from the Internet as long as they are launched with public\n   * IPs (controlled on the AutoScalingGroup or other constructs that launch\n   * instances).\n   *\n   * Public subnets route outbound traffic via an Internet Gateway.\n   */\n  PUBLIC = \"Public\",\n}\n\n/**\n * Customize subnets that are selected for placement of ENIs\n *\n * Constructs that allow customization of VPC placement use parameters of this\n * type to provide placement settings.\n *\n * By default, the instances are placed in the private subnets.\n */\nexport interface SubnetSelection {\n  /**\n   * Select all subnets of the given type\n   *\n   * At most one of `subnetType` and `subnetGroupName` can be supplied.\n   *\n   * @default SubnetType.PRIVATE_WITH_EGRESS (or ISOLATED or PUBLIC if there are no PRIVATE_WITH_EGRESS subnets)\n   */\n  readonly subnetType?: SubnetType;\n\n  /**\n   * Select subnets only in the given AZs.\n   *\n   * @default no filtering on AZs is done\n   */\n  readonly availabilityZones?: string[];\n\n  /**\n   * Select the subnet group with the given name\n   *\n   * Select the subnet group with the given name. This only needs\n   * to be used if you have multiple subnet groups of the same type\n   * and you need to distinguish between them. Otherwise, prefer\n   * `subnetType`.\n   *\n   * This field does not select individual subnets, it selects all subnets that\n   * share the given subnet group name. This is the name supplied in\n   * `subnetConfiguration`.\n   *\n   * At most one of `subnetType` and `subnetGroupName` can be supplied.\n   *\n   * @default - Selection by type instead of by name\n   */\n  readonly subnetGroupName?: string;\n\n  /**\n   * Alias for `subnetGroupName`\n   *\n   * Select the subnet group with the given name. This only needs\n   * to be used if you have multiple subnet groups of the same type\n   * and you need to distinguish between them.\n   *\n   * @deprecated Use `subnetGroupName` instead\n   */\n  readonly subnetName?: string;\n\n  /**\n   * If true, return at most one subnet per AZ\n   *\n   * @default false\n   */\n  readonly onePerAz?: boolean;\n\n  /**\n   * List of provided subnet filters.\n   *\n   * @default - none\n   */\n  readonly subnetFilters?: SubnetFilter[];\n\n  /**\n   * Explicitly select individual subnets\n   *\n   * Use this if you don't want to automatically use all subnets in\n   * a group, but have a need to control selection down to\n   * individual subnets.\n   *\n   * Cannot be specified together with `subnetType` or `subnetGroupName`.\n   *\n   * @default - Use all subnets in a selected group (all private subnets by default)\n   */\n  readonly subnets?: ISubnet[];\n}\n\n/**\n * Result of selecting a subset of subnets from a VPC\n */\nexport interface SelectedSubnets {\n  /**\n   * The subnet IDs\n   */\n  readonly subnetIds: string[];\n\n  /**\n   * The respective AZs of each subnet\n   */\n  readonly availabilityZones: string[];\n\n  /**\n   * Dependency representing internet connectivity for these subnets\n   */\n  readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * Selected subnet objects\n   */\n  readonly subnets: ISubnet[];\n\n  /**\n   * Whether any of the given subnets are from the VPC's public subnets.\n   */\n  readonly hasPublic: boolean;\n\n  /**\n   * The subnet selection is not actually real yet\n   *\n   * If this value is true, don't validate anything about the subnets. The count\n   * or identities are not known yet, and the validation will most likely fail\n   * which will prevent a successful lookup.\n   *\n   * @default false\n   */\n  readonly isPendingLookup?: boolean;\n}\n\n/**\n * A new or imported VPC\n */\nabstract class VpcBase extends AwsConstructBase implements IVpc {\n  /**\n   * Identifier for this VPC\n   */\n  public abstract readonly vpcId: string;\n\n  /**\n   * Arn of this VPC\n   */\n  public abstract readonly vpcArn: string;\n\n  /**\n   * CIDR range for this VPC\n   */\n  public abstract readonly vpcCidrBlock: string;\n\n  /**\n   * List of public subnets in this VPC\n   */\n  public abstract readonly publicSubnets: ISubnet[];\n\n  /**\n   * List of private subnets in this VPC\n   */\n  public abstract readonly privateSubnets: ISubnet[];\n\n  /**\n   * List of isolated subnets in this VPC\n   */\n  public abstract readonly isolatedSubnets: ISubnet[];\n\n  /**\n   * AZs for this VPC\n   */\n  public abstract readonly availabilityZones: string[];\n\n  /**\n   * Dependencies for internet connectivity\n   */\n  public abstract readonly internetConnectivityEstablished: IDependable;\n\n  public get vpcOutputs(): VpcOutputs {\n    return {\n      availabilityZones: this.availabilityZones,\n      isolatedSubnetIds: this.isolatedSubnets.map((s) => s.subnetId),\n      privateSubnetIds: this.privateSubnets.map((s) => s.subnetId),\n      publicSubnetIds: this.publicSubnets.map((s) => s.subnetId),\n      vpcArn: this.vpcArn,\n      vpcCidrBlock: this.vpcCidrBlock,\n      vpcId: this.vpcId,\n      vpnGatewayId: this.vpnGatewayId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.vpcOutputs;\n  }\n  /**\n   * Dependencies for NAT connectivity\n   *\n   * @deprecated - This value is no longer used.\n   */\n  protected readonly natDependencies = new Array<IConstruct>();\n\n  /**\n   * If this is set to true, don't error out on trying to select subnets\n   */\n  protected incompleteSubnetDefinition: boolean = false;\n\n  /**\n   * Mutable private field for the vpnGatewayId\n   *\n   * @internal\n   */\n  protected _vpnGatewayId?: string;\n\n  /**\n   * Returns IDs of selected subnets\n   */\n  public selectSubnets(selection: SubnetSelection = {}): SelectedSubnets {\n    const subnets = this.selectSubnetObjects(selection);\n    const pubs = new Set(this.publicSubnets);\n\n    return {\n      subnetIds: subnets.map((s) => s.subnetId),\n      get availabilityZones(): string[] {\n        return subnets.map((s) => s.availabilityZone);\n      },\n      internetConnectivityEstablished: tap(new CompositeDependable(), (d) =>\n        subnets.forEach((s) => d.add(s.internetConnectivityEstablished)),\n      ),\n      subnets,\n      hasPublic: subnets.some((s) => pubs.has(s)),\n      isPendingLookup: this.incompleteSubnetDefinition,\n    };\n  }\n\n  /**\n   * Adds a VPN Gateway to this VPC\n   */\n  public enableVpnGateway(options: EnableVpnGatewayOptions): void {\n    if (this.vpnGatewayId) {\n      throw new Error(\"The VPN Gateway has already been enabled.\");\n    }\n\n    const vpnGateway = new VpnGateway(this, \"VpnGateway\", {\n      amazonSideAsn: options.amazonSideAsn,\n      type: VpnConnectionType.IPSEC_1,\n    });\n\n    this._vpnGatewayId = vpnGateway.gatewayId;\n\n    const attachment = new vpnGatewayAttachment.VpnGatewayAttachment(\n      this,\n      \"VPCVPNGW\",\n      {\n        vpcId: this.vpcId,\n        vpnGatewayId: this._vpnGatewayId,\n      },\n    );\n\n    // Propagate routes on route tables associated with the right subnets\n    const vpnRoutePropagation = options.vpnRoutePropagation ?? [{}];\n    const routeTableIds = allRouteTableIds(\n      flatten(vpnRoutePropagation.map((s) => this.selectSubnets(s).subnets)),\n    );\n\n    if (routeTableIds.length === 0) {\n      Annotations.of(this).addError(\n        `enableVpnGateway: no subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`,\n      );\n    }\n\n    for (let i = 0; i < routeTableIds.length; i++) {\n      const routePropagation =\n        new vpnGatewayRoutePropagation.VpnGatewayRoutePropagation(\n          this,\n          `RoutePropagation${i}`,\n          {\n            routeTableId: routeTableIds[i],\n            vpnGatewayId: this._vpnGatewayId,\n          },\n        );\n      // The aws_vpn_gateway_route_propagation resource cannot use the VPN gateway\n      // until it has successfully attached to the VPC.\n      // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html\n      routePropagation.node.addDependency(attachment);\n    }\n  }\n\n  /**\n   * Adds a new VPN connection to this VPC\n   */\n  public addVpnConnection(\n    id: string,\n    options: VpnConnectionOptions,\n  ): VpnConnection {\n    return new VpnConnection(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Adds a new client VPN endpoint to this VPC\n   */\n  public addClientVpnEndpoint(\n    id: string,\n    options: ClientVpnEndpointOptions,\n  ): ClientVpnEndpoint {\n    return new ClientVpnEndpoint(this, id, {\n      ...options,\n      vpc: this,\n    });\n  }\n\n  /**\n   * Adds a new interface endpoint to this VPC\n   */\n  public addInterfaceEndpoint(\n    id: string,\n    options: InterfaceVpcEndpointOptions,\n  ): InterfaceVpcEndpoint {\n    return new InterfaceVpcEndpoint(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Adds a new gateway endpoint to this VPC\n   */\n  public addGatewayEndpoint(\n    id: string,\n    options: GatewayVpcEndpointOptions,\n  ): GatewayVpcEndpoint {\n    return new GatewayVpcEndpoint(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n   * Adds a new flow log to this VPC\n   */\n  public addFlowLog(id: string, options?: FlowLogOptions): FlowLog {\n    return new FlowLog(this, id, {\n      resourceType: FlowLogResourceType.fromVpc(this),\n      ...options,\n    });\n  }\n\n  /**\n   * Returns the id of the VPN Gateway (if enabled)\n   */\n  public get vpnGatewayId(): string | undefined {\n    return this._vpnGatewayId;\n  }\n\n  /**\n   * Return the subnets appropriate for the placement strategy\n   */\n  protected selectSubnetObjects(selection: SubnetSelection = {}): ISubnet[] {\n    selection = this.reifySelectionDefaults(selection);\n\n    if (selection.subnets !== undefined) {\n      return selection.subnets;\n    }\n\n    let subnets;\n\n    if (selection.subnetGroupName !== undefined) {\n      // Select by name\n      subnets = this.selectSubnetObjectsByName(selection.subnetGroupName);\n    } else {\n      // Or specify by type\n      const type = selection.subnetType || SubnetType.PRIVATE_WITH_EGRESS;\n      subnets = this.selectSubnetObjectsByType(type);\n    }\n\n    // Apply all the filters\n    subnets = this.applySubnetFilters(subnets, selection.subnetFilters ?? []);\n\n    return subnets;\n  }\n\n  private applySubnetFilters(\n    subnets: ISubnet[],\n    filters: SubnetFilter[],\n  ): ISubnet[] {\n    let filtered = subnets;\n    // Apply each filter in sequence\n    for (const filter of filters) {\n      filtered = filter.selectSubnets(filtered);\n    }\n    return filtered;\n  }\n\n  private selectSubnetObjectsByName(groupName: string) {\n    const allSubnets = [\n      ...this.publicSubnets,\n      ...this.privateSubnets,\n      ...this.isolatedSubnets,\n    ];\n    const subnets = allSubnets.filter(\n      (s) => subnetGroupNameFromConstructId(s) === groupName,\n    );\n\n    if (subnets.length === 0 && !this.incompleteSubnetDefinition) {\n      const names = Array.from(\n        new Set(allSubnets.map(subnetGroupNameFromConstructId)),\n      );\n      throw new Error(\n        `There are no subnet groups with name '${groupName}' in this VPC. Available names: ${names}`,\n      );\n    }\n\n    return subnets;\n  }\n\n  private selectSubnetObjectsByType(subnetType: SubnetType) {\n    const allSubnets = {\n      [SubnetType.PRIVATE_ISOLATED]: this.isolatedSubnets,\n      [SubnetType.ISOLATED]: this.isolatedSubnets,\n      [SubnetType.PRIVATE_WITH_NAT]: this.privateSubnets,\n      [SubnetType.PRIVATE_WITH_EGRESS]: this.privateSubnets,\n      [SubnetType.PRIVATE]: this.privateSubnets,\n      [SubnetType.PUBLIC]: this.publicSubnets,\n    };\n\n    const subnets = allSubnets[subnetType];\n\n    // Force merge conflict here with https://github.com/aws/aws-cdk/pull/4089\n    // see ImportedVpc\n\n    if (subnets.length === 0 && !this.incompleteSubnetDefinition) {\n      const availableTypes = Object.entries(allSubnets)\n        .filter(([_, subs]) => subs.length > 0)\n        .map(([typeName, _]) => typeName);\n      throw new Error(\n        `There are no '${subnetType}' subnet groups in this VPC. Available types: ${availableTypes}`,\n      );\n    }\n\n    return subnets;\n  }\n\n  /**\n   * Validate the fields in a SubnetSelection object, and reify defaults if necessary\n   *\n   * In case of default selection, select the first type of PRIVATE, ISOLATED,\n   * PUBLIC (in that order) that has any subnets.\n   */\n  private reifySelectionDefaults(placement: SubnetSelection): SubnetSelection {\n    if (placement.subnetName !== undefined) {\n      if (placement.subnetGroupName !== undefined) {\n        throw new Error(\n          \"Please use only 'subnetGroupName' ('subnetName' is deprecated and has the same behavior)\",\n        );\n      } else {\n        // \"@aws-cdk/aws-ec2:subnetNameDeprecated\",\n        Annotations.of(this).addWarning(\n          \"Usage of 'subnetName' in SubnetSelection is deprecated, use 'subnetGroupName' instead\",\n        );\n      }\n      placement = { ...placement, subnetGroupName: placement.subnetName };\n    }\n\n    const exclusiveSelections: Array<keyof SubnetSelection> = [\n      \"subnets\",\n      \"subnetType\",\n      \"subnetGroupName\",\n    ];\n    const providedSelections = exclusiveSelections.filter(\n      (key) => placement[key] !== undefined,\n    );\n    if (providedSelections.length > 1) {\n      throw new Error(\n        `Only one of '${providedSelections}' can be supplied to subnet selection.`,\n      );\n    }\n\n    if (\n      placement.subnetType === undefined &&\n      placement.subnetGroupName === undefined &&\n      placement.subnets === undefined\n    ) {\n      // Return default subnet type based on subnets that actually exist\n      let subnetType = this.privateSubnets.length\n        ? SubnetType.PRIVATE_WITH_EGRESS\n        : this.isolatedSubnets.length\n          ? SubnetType.PRIVATE_ISOLATED\n          : SubnetType.PUBLIC;\n      placement = { ...placement, subnetType: subnetType };\n    }\n\n    // Establish which subnet filters are going to be used\n    let subnetFilters = placement.subnetFilters ?? [];\n\n    // Backwards compatibility with existing `availabilityZones` and `onePerAz` functionality\n    if (placement.availabilityZones !== undefined) {\n      // Filter by AZs, if specified\n      subnetFilters.push(\n        SubnetFilter.availabilityZones(placement.availabilityZones),\n      );\n    }\n    if (!!placement.onePerAz) {\n      // Ensure one per AZ if specified\n      subnetFilters.push(SubnetFilter.onePerAz());\n    }\n\n    // Overwrite the provided placement filters and remove the availabilityZones and onePerAz properties\n    placement = {\n      ...placement,\n      subnetFilters: subnetFilters,\n      availabilityZones: undefined,\n      onePerAz: undefined,\n    };\n    const { availabilityZones, onePerAz, ...rest } = placement;\n\n    return rest;\n  }\n}\n\n/**\n * Properties that reference an external Vpc\n */\nexport interface VpcAttributes {\n  /**\n   * VPC's identifier\n   */\n  readonly vpcId: string;\n\n  /**\n   * VPC's CIDR range\n   *\n   * @default - Retrieving the CIDR from the VPC will fail\n   */\n  readonly vpcCidrBlock?: string;\n\n  /**\n   * List of availability zones for the subnets in this VPC.\n   */\n  readonly availabilityZones: string[];\n\n  /**\n   * List of public subnet IDs\n   *\n   * Must be undefined or match the availability zones in length and order.\n   *\n   * @default - The VPC does not have any public subnets\n   */\n  readonly publicSubnetIds?: string[];\n\n  /**\n   * List of names for the public subnets\n   *\n   * Must be undefined or have a name for every public subnet group.\n   *\n   * @default - All public subnets will have the name `Public`\n   */\n  readonly publicSubnetNames?: string[];\n\n  /**\n   * List of IDs of route tables for the public subnets.\n   *\n   * Must be undefined or have a name for every public subnet group.\n   *\n   * @default - Retrieving the route table ID of any public subnet will fail\n   */\n  readonly publicSubnetRouteTableIds?: string[];\n\n  /**\n   * List of IPv4 CIDR blocks for the public subnets.\n   *\n   * Must be undefined or have an entry for every public subnet group.\n   *\n   * @default - Retrieving the IPv4 CIDR block of any public subnet will fail\n   */\n  readonly publicSubnetIpv4CidrBlocks?: string[];\n\n  /**\n   * List of private subnet IDs\n   *\n   * Must be undefined or match the availability zones in length and order.\n   *\n   * @default - The VPC does not have any private subnets\n   */\n  readonly privateSubnetIds?: string[];\n\n  /**\n   * List of names for the private subnets\n   *\n   * Must be undefined or have a name for every private subnet group.\n   *\n   * @default - All private subnets will have the name `Private`\n   */\n  readonly privateSubnetNames?: string[];\n\n  /**\n   * List of IDs of route tables for the private subnets.\n   *\n   * Must be undefined or have a name for every private subnet group.\n   *\n   * @default - Retrieving the route table ID of any private subnet will fail\n   */\n  readonly privateSubnetRouteTableIds?: string[];\n\n  /**\n   * List of IPv4 CIDR blocks for the private subnets.\n   *\n   * Must be undefined or have an entry for every private subnet group.\n   *\n   * @default - Retrieving the IPv4 CIDR block of any private subnet will fail\n   */\n  readonly privateSubnetIpv4CidrBlocks?: string[];\n\n  /**\n   * List of isolated subnet IDs\n   *\n   * Must be undefined or match the availability zones in length and order.\n   *\n   * @default - The VPC does not have any isolated subnets\n   */\n  readonly isolatedSubnetIds?: string[];\n\n  /**\n   * List of names for the isolated subnets\n   *\n   * Must be undefined or have a name for every isolated subnet group.\n   *\n   * @default - All isolated subnets will have the name `Isolated`\n   */\n  readonly isolatedSubnetNames?: string[];\n\n  /**\n   * List of IDs of route tables for the isolated subnets.\n   *\n   * Must be undefined or have a name for every isolated subnet group.\n   *\n   * @default - Retrieving the route table ID of any isolated subnet will fail\n   */\n  readonly isolatedSubnetRouteTableIds?: string[];\n\n  /**\n   * List of IPv4 CIDR blocks for the isolated subnets.\n   *\n   * Must be undefined or have an entry for every isolated subnet group.\n   *\n   * @default - Retrieving the IPv4 CIDR block of any isolated subnet will fail\n   */\n  readonly isolatedSubnetIpv4CidrBlocks?: string[];\n\n  /**\n   * VPN gateway's identifier\n   */\n  readonly vpnGatewayId?: string;\n\n  /**\n   * The region the VPC is in\n   *\n   * @default - The region of the stack where the VPC belongs to\n   */\n  readonly region?: string;\n}\n\nexport interface SubnetAttributes {\n  /**\n   * The Availability Zone the subnet is located in\n   *\n   * @default - No AZ information, cannot use AZ selection features\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * The IPv4 CIDR block associated with the subnet\n   *\n   * @default - No CIDR information, cannot use CIDR filter features\n   */\n  readonly ipv4CidrBlock?: string;\n\n  /**\n   * The ID of the route table for this particular subnet\n   *\n   * @default - No route table information, cannot create VPC endpoints\n   */\n  readonly routeTableId?: string;\n\n  /**\n   * The subnetId for this particular subnet\n   */\n  readonly subnetId: string;\n\n  /**\n   * Whether to register Terraform outputs for this TerraConstruct\n   *\n   * @default false\n   */\n  readonly registerOutputs?: boolean;\n\n  /**\n   * Optional override for the outputs name\n   *\n   * @default id\n   */\n  readonly outputName?: string;\n}\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Configuration for Vpc\n */\nexport interface VpcProps {\n  /**\n   * The protocol of the vpc.\n   *\n   * Options are IPv4 only or dual stack.\n   *\n   * @default IpProtocol.IPV4_ONLY\n   */\n  readonly ipProtocol?: IpProtocol;\n\n  /**\n   * The Provider to use to allocate IPv4 Space to your VPC.\n   *\n   * Options include static allocation or from a pool.\n   *\n   * Note this is specific to IPv4 addresses.\n   *\n   * @default compute.IpAddresses.cidr\n   */\n  readonly ipAddresses?: IIpAddresses;\n\n  /**\n   * The CIDR range to use for the VPC, e.g. '10.0.0.0/16'.\n   *\n   * Should be a minimum of /28 and maximum size of /16. The range will be\n   * split across all subnets per Availability Zone.\n   *\n   * @default Vpc.DEFAULT_CIDR_RANGE\n   *\n   * @deprecated Use ipAddresses instead\n   */\n  readonly cidr?: string;\n\n  /**\n   * Indicates whether the instances launched in the VPC get public DNS hostnames.\n   *\n   * If this attribute is true, instances in the VPC get public DNS hostnames,\n   * but only if the enableDnsSupport attribute is also set to true.\n   *\n   * @default true\n   */\n  readonly enableDnsHostnames?: boolean;\n\n  /**\n   * Indicates whether the DNS resolution is supported for the VPC.\n   *\n   * If this attribute is false, the Amazon-provided DNS server in the VPC that\n   * resolves public DNS hostnames to IP addresses is not enabled. If this\n   * attribute is true, queries to the Amazon provided DNS server at the\n   * 169.254.169.253 IP address, or the reserved IP address at the base of the\n   * VPC IPv4 network range plus two will succeed.\n   *\n   * @default true\n   */\n  readonly enableDnsSupport?: boolean;\n\n  /**\n   * The default tenancy of instances launched into the VPC.\n   *\n   * By setting this to dedicated tenancy, instances will be launched on\n   * hardware dedicated to a single AWS customer, unless specifically specified\n   * at instance launch time. Please note, not all instance types are usable\n   * with Dedicated tenancy.\n   *\n   * @default DefaultInstanceTenancy.Default (shared) tenancy\n   */\n  readonly defaultInstanceTenancy?: DefaultInstanceTenancy;\n\n  /**\n   * Define the maximum number of AZs to use in this region\n   *\n   * If the region has more AZs than you want to use (for example, because of\n   * EIP limits), pick a lower number here. The AZs will be sorted and picked\n   * from the start of the list.\n   *\n   * If you pick a higher number than the number of AZs in the region, all AZs\n   * in the region will be selected. To use \"all AZs\" available to your\n   * account, use a high number (such as 99).\n   *\n   * Be aware that environment-agnostic stacks will be created with access to\n   * only 2 AZs, so to use more than 2 AZs, be sure to specify the account and\n   * region on your stack.\n   *\n   * Specify this option only if you do not specify `availabilityZones`.\n   *\n   * @default 3\n   */\n  readonly maxAzs?: number;\n\n  /**\n   * Define the number of AZs to reserve.\n   *\n   * When specified, the IP space is reserved for the azs but no actual\n   * resources are provisioned.\n   *\n   * @default 0\n   */\n  readonly reservedAzs?: number;\n\n  /**\n   * Availability zones this VPC spans.\n   *\n   * Specify this option only if you do not specify `maxAzs`.\n   *\n   * @default - a subset of AZs of the stack\n   */\n  readonly availabilityZones?: string[];\n\n  /**\n   * The number of NAT Gateways/Instances to create.\n   *\n   * The type of NAT gateway or instance will be determined by the\n   * `natGatewayProvider` parameter.\n   *\n   * You can set this number lower than the number of Availability Zones in your\n   * VPC in order to save on NAT cost. Be aware you may be charged for\n   * cross-AZ data traffic instead.\n   *\n   * @default - One NAT gateway/instance per Availability Zone\n   */\n  readonly natGateways?: number;\n\n  /**\n   * Configures the subnets which will have NAT Gateways/Instances\n   *\n   * You can pick a specific group of subnets by specifying the group name;\n   * the picked subnets must be public subnets.\n   *\n   * Only necessary if you have more than one public subnet group.\n   *\n   * @default - All public subnets.\n   */\n  readonly natGatewaySubnets?: SubnetSelection;\n\n  /**\n   * What type of NAT provider to use\n   *\n   * Select between NAT gateways or NAT instances. NAT gateways\n   * may not be available in all AWS regions.\n   *\n   * @default NatProvider.gateway()\n   *\n   */\n  readonly natGatewayProvider?: NatProvider;\n\n  /**\n   * Configure the subnets to build for each AZ\n   *\n   * Each entry in this list configures a Subnet Group; each group will contain a\n   * subnet for each Availability Zone.\n   *\n   * For example, if you want 1 public subnet, 1 private subnet, and 1 isolated\n   * subnet in each AZ provide the following:\n   *\n   * ```ts\n   * new compute.Vpc(this, 'VPC', {\n   *   subnetConfiguration: [\n   *      {\n   *        cidrMask: 24,\n   *        name: 'ingress',\n   *        subnetType: compute.SubnetType.PUBLIC,\n   *      },\n   *      {\n   *        cidrMask: 24,\n   *        name: 'application',\n   *        subnetType: compute.SubnetType.PRIVATE_WITH_EGRESS,\n   *      },\n   *      {\n   *        cidrMask: 28,\n   *        name: 'rds',\n   *        subnetType: compute.SubnetType.PRIVATE_ISOLATED,\n   *      }\n   *   ]\n   * });\n   * ```\n   *\n   * @default - The VPC CIDR will be evenly divided between 1 public and 1\n   * private subnet per AZ.\n   */\n  readonly subnetConfiguration?: SubnetConfiguration[];\n\n  /**\n   * Indicates whether a VPN gateway should be created and attached to this VPC.\n   *\n   * @default - true when vpnGatewayAsn or vpnConnections is specified\n   */\n  readonly vpnGateway?: boolean;\n\n  /**\n   * The private Autonomous System Number (ASN) for the VPN gateway.\n   *\n   * @default - Amazon default ASN.\n   */\n  readonly vpnGatewayAsn?: number;\n\n  /**\n   * VPN connections to this VPC.\n   *\n   * @default - No connections.\n   */\n  readonly vpnConnections?: { [id: string]: VpnConnectionOptions };\n\n  /**\n   * Where to propagate VPN routes.\n   *\n   * @default - On the route tables associated with private subnets. If no\n   * private subnets exists, isolated subnets are used. If no isolated subnets\n   * exists, public subnets are used.\n   */\n  readonly vpnRoutePropagation?: SubnetSelection[];\n\n  /**\n   * Gateway endpoints to add to this VPC.\n   *\n   * @default - None.\n   */\n  readonly gatewayEndpoints?: { [id: string]: GatewayVpcEndpointOptions };\n\n  /**\n   * Flow logs to add to this VPC.\n   *\n   * @default - No flow logs.\n   */\n  readonly flowLogs?: { [id: string]: FlowLogOptions };\n\n  /**\n   * The VPC name.\n   *\n   * Since the VPC resource doesn't support providing a physical name, the value provided here will be recorded in the `Name` tag\n   *\n   * @default this.node.path\n   */\n  readonly vpcName?: string;\n\n  // /**\n  //  * If set to true then the default inbound & outbound rules will be removed\n  //  * from the default security group\n  //  *\n  //  * @default true if '@aws-cdk/aws-ec2:restrictDefaultSecurityGroup' is enabled, false otherwise\n  //  */\n  // readonly restrictDefaultSecurityGroup?: boolean;\n\n  /**\n   * If set to false then disable the creation of the default internet gateway\n   *\n   * @default true\n   */\n  readonly createInternetGateway?: boolean;\n\n  /**\n   * The Provider to use to allocate IPv6 Space to your VPC.\n   *\n   * Options include amazon provided CIDR block.\n   *\n   * Note this is specific to IPv6 addresses.\n   *\n   * @default Ipv6Addresses.amazonProvided\n   */\n  readonly ipv6Addresses?: IIpv6Addresses;\n}\n\n/**\n * The default tenancy of instances launched into the VPC.\n */\nexport enum DefaultInstanceTenancy {\n  /**\n   * Instances can be launched with any tenancy.\n   */\n  DEFAULT = \"default\",\n\n  /**\n   * Any instance launched into the VPC automatically has dedicated tenancy, unless you launch it with the default tenancy.\n   */\n  DEDICATED = \"dedicated\",\n}\n\n/**\n * Specify configuration parameters for a single subnet group in a VPC.\n */\nexport interface SubnetConfiguration {\n  /**\n   * The number of leading 1 bits in the routing mask.\n   *\n   * The number of available IP addresses in each subnet of this group\n   * will be equal to `2^(32 - cidrMask) - 2`.\n   *\n   * Valid values are `16--28`.\n   *\n   * Note this is specific to IPv4 addresses.\n   *\n   * @default - Available IP space is evenly divided across subnets.\n   */\n  readonly cidrMask?: number;\n\n  /**\n   * The type of Subnet to configure.\n   *\n   * The Subnet type will control the ability to route and connect to the\n   * Internet.\n   */\n  readonly subnetType: SubnetType;\n\n  /**\n   * Logical name for the subnet group.\n   *\n   * This name can be used when selecting VPC subnets to distinguish\n   * between different subnet groups of the same type.\n   */\n  readonly name: string;\n\n  /**\n   * Controls if subnet IP space needs to be reserved.\n   *\n   * When true, the IP space for the subnet is reserved but no actual\n   * resources are provisioned. This space is only dependent on the\n   * number of availability zones and on `cidrMask` - all other subnet\n   * properties are ignored.\n   *\n   * @default false\n   */\n  readonly reserved?: boolean;\n\n  /**\n   * Controls if a public IPv4 address is associated to an instance at launch\n   *\n   * Note this is specific to IPv4 addresses.\n   *\n   * @default true in Subnet.Public of IPV4_ONLY VPCs, false otherwise\n   */\n  readonly mapPublicIpOnLaunch?: boolean;\n\n  /**\n   * This property is specific to dual stack VPCs.\n   *\n   * If set to false, then an IPv6 address will not be automatically assigned.\n   *\n   * Note this is specific to IPv6 addresses.\n   *\n   * @default true\n   */\n  readonly ipv6AssignAddressOnCreation?: boolean;\n}\n\n/**\n * Define an AWS Virtual Private Cloud\n *\n * See the package-level documentation of this package for an overview\n * of the various dimensions in which you can configure your VPC.\n *\n * For example:\n *\n * ```ts\n * const vpc = new compute.Vpc(this, 'TheVPC', {\n *   ipAddresses: compute.IpAddresses.cidr('10.0.0.0/16'),\n * })\n *\n * // Iterate the private subnets\n * const selection = vpc.selectSubnets({\n *   subnetType: compute.SubnetType.PRIVATE_WITH_EGRESS\n * });\n *\n * for (const subnet of selection.subnets) {\n *   // ...\n * }\n * ```\n *\n * @resource aws_vpc\n */\nexport class Vpc extends VpcBase {\n  /**\n   * The default CIDR range used when creating VPCs.\n   * This can be overridden using VpcProps when creating a VPCNetwork resource.\n   * e.g. new Vpc(this, { cidr: '192.168.0.0./16' })\n   *\n   * Note this is specific to the IPv4 CIDR.\n   */\n  public static readonly DEFAULT_CIDR_RANGE: string = \"10.0.0.0/16\";\n\n  /**\n   * The default subnet configuration\n   *\n   * 1 Public and 1 Private subnet per AZ evenly split\n   */\n  public static readonly DEFAULT_SUBNETS: SubnetConfiguration[] = [\n    {\n      subnetType: SubnetType.PUBLIC,\n      name: defaultSubnetName(SubnetType.PUBLIC),\n    },\n    {\n      subnetType: SubnetType.PRIVATE_WITH_EGRESS,\n      name: defaultSubnetName(SubnetType.PRIVATE_WITH_EGRESS),\n    },\n  ];\n\n  /**\n   * The default subnet configuration if natGateways specified to be 0\n   *\n   * 1 Public and 1 Isolated Subnet per AZ evenly split\n   */\n  public static readonly DEFAULT_SUBNETS_NO_NAT: SubnetConfiguration[] = [\n    {\n      subnetType: SubnetType.PUBLIC,\n      name: defaultSubnetName(SubnetType.PUBLIC),\n    },\n    {\n      subnetType: SubnetType.PRIVATE_ISOLATED,\n      name: defaultSubnetName(SubnetType.PRIVATE_ISOLATED),\n    },\n  ];\n\n  /**\n   * Import a VPC by supplying all attributes directly\n   *\n   * NOTE: using `fromVpcAttributes()` with deploy-time parameters (like a `TerraformVariable`\n   * to represent a list of subnet IDs) sometimes accidentally works. It happens to work for\n   * constructs that need a list of subnets (like `AutoScalingGroup` and `eks.Cluster`)\n   * but it does not work for constructs that need individual subnets (like`Instance`).\n   * See https://github.com/aws/aws-cdk/issues/4118 for more information.\n   */\n  public static fromVpcAttributes(\n    // TODO: Prefer to use `Vpc.fromLookup()` instead.\n    scope: Construct,\n    id: string,\n    attrs: VpcAttributes,\n  ): IVpc {\n    return new ImportedVpc(scope, id, attrs, false);\n  }\n\n  // TODO: Add Grid Lookup support\n  // /**\n  //  * Import an existing VPC by querying the AWS environment this stack is deployed to.\n  //  *\n  //  * This function only needs to be used to use VPCs not defined in your CDK\n  //  * application. If you are looking to share a VPC between stacks, you can\n  //  * pass the `Vpc` object between stacks and use it as normal.\n  //  *\n  //  * Calling this method will lead to a lookup when the CDK CLI is executed.\n  //  * You can therefore not use any values that will only be available at\n  //  * CloudFormation execution time (i.e., Tokens).\n  //  *\n  //  * The VPC information will be cached in `cdk.context.json` and the same VPC\n  //  * will be used on future runs. To refresh the lookup, you will have to\n  //  * evict the value from the cache using the `cdk context` command. See\n  //  * https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.\n  //  */\n  // public static fromLookup(\n  //   scope: Construct,\n  //   id: string,\n  //   options: VpcLookupOptions,\n  // ): IVpc {\n  //   if (\n  //     Token.isUnresolved(options.vpcId) ||\n  //     Token.isUnresolved(options.vpcName) ||\n  //     Object.values(options.tags || {}).some(Token.isUnresolved) ||\n  //     Object.keys(options.tags || {}).some(Token.isUnresolved)\n  //   ) {\n  //     throw new Error(\n  //       \"All arguments to Vpc.fromLookup() must be concrete (no Tokens)\",\n  //     );\n  //   }\n\n  //   const filter: { [key: string]: string } = makeTagFilter(options.tags);\n\n  //   // We give special treatment to some tags\n  //   if (options.vpcId) {\n  //     filter[\"vpc-id\"] = options.vpcId;\n  //   }\n  //   if (options.vpcName) {\n  //     filter[\"tag:Name\"] = options.vpcName;\n  //   }\n  //   if (options.ownerAccountId) {\n  //     filter[\"owner-id\"] = options.ownerAccountId;\n  //   }\n  //   if (options.isDefault !== undefined) {\n  //     filter.isDefault = options.isDefault ? \"true\" : \"false\";\n  //   }\n\n  //   const overrides: { [key: string]: string } = {};\n  //   if (options.region) {\n  //     overrides.region = options.region;\n  //   }\n\n  //   const attributes: cxapi.VpcContextResponse = ContextProvider.getValue(\n  //     scope,\n  //     {\n  //       provider: cxschema.ContextProvider.VPC_PROVIDER,\n  //       props: {\n  //         ...overrides,\n  //         filter,\n  //         returnAsymmetricSubnets: true,\n  //         returnVpnGateways: options.returnVpnGateways,\n  //         subnetGroupNameTag: options.subnetGroupNameTag,\n  //       } as cxschema.VpcContextQuery,\n  //       dummyValue: undefined,\n  //     },\n  //   ).value;\n\n  //   return new LookedUpVpc(\n  //     scope,\n  //     id,\n  //     attributes ?? DUMMY_VPC_PROPS,\n  //     attributes === undefined,\n  //   );\n\n  //   /**\n  //    * Prefixes all keys in the argument with `tag:`.`\n  //    */\n  //   function makeTagFilter(tags: { [name: string]: string } | undefined): {\n  //     [name: string]: string;\n  //   } {\n  //     const result: { [name: string]: string } = {};\n  //     for (const [name, value] of Object.entries(tags || {})) {\n  //       result[`tag:${name}`] = value;\n  //     }\n  //     return result;\n  //   }\n  // }\n\n  /**\n   * Identifier for this VPC\n   */\n  public readonly vpcId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly vpcArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly vpcCidrBlock: string;\n\n  /**\n   * @attribute\n   */\n  public readonly vpcDefaultNetworkAcl: string;\n\n  // TODO: use aws_vpc_ipv4_cidr_block_association sub resources?\n  // provider-aws aws_vpc does not have vpcCidrBlockAssociations\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly vpcCidrBlockAssociations: string[];\n\n  /**\n   * @attribute\n   */\n  public readonly vpcDefaultSecurityGroup: string;\n\n  // TODO: use aws_vpc_ipv6_cidr_block_association sub resources?\n  // provider-aws aws_vpc does not have vpcIpv6CidrBlocks\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly vpcIpv6CidrBlocks: string[];\n\n  /**\n   * @attribute\n   */\n  public readonly vpcIpv6CidrBlock: string;\n\n  /**\n   * List of public subnets in this VPC\n   */\n  public readonly publicSubnets: ISubnet[] = [];\n\n  /**\n   * List of private subnets in this VPC\n   */\n  public readonly privateSubnets: ISubnet[] = [];\n\n  /**\n   * List of isolated subnets in this VPC\n   */\n  public readonly isolatedSubnets: ISubnet[] = [];\n\n  /**\n   * AZs for this VPC\n   */\n  public readonly availabilityZones: string[];\n\n  /**\n   * Internet Gateway for the VPC. Note that in case the VPC is configured only\n   * with ISOLATED subnets, this attribute will be `undefined`.\n   */\n  public readonly internetGatewayId?: string;\n\n  public readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * Indicates if instances launched in this VPC will have public DNS hostnames.\n   */\n  public readonly dnsHostnamesEnabled: boolean;\n\n  /**\n   * Indicates if DNS support is enabled for this VPC.\n   */\n  public readonly dnsSupportEnabled: boolean;\n\n  /**\n   * The VPC resource\n   */\n  private readonly resource: vpc.Vpc;\n\n  /**\n   * Indicates if IPv4 addresses will be used in the VPC.\n   *\n   * True for IPV4_ONLY and DUAL_STACK VPCs.\n   */\n  private readonly useIpv4: boolean;\n\n  /**\n   * Indicates if IPv6 addresses will be used in the VPC.\n   *\n   * True for DUAL_STACK VPCs. False for IPV4_ONLY VPCs.\n   */\n  private readonly useIpv6: boolean;\n\n  /**\n   * The provider of ipv4 addresses\n   */\n  private readonly ipAddresses: IIpAddresses;\n\n  /**\n   * The provider of IPv6 addresses.\n   */\n  private readonly ipv6Addresses?: IIpv6Addresses;\n\n  /**\n   * The IPv6 CIDR block CFN resource.\n   *\n   * Needed to create a dependency for the subnets.\n   */\n  private readonly ipv6CidrBlock?: vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation;\n\n  /**\n   * The IPv6 CIDR block string representation.\n   */\n  private readonly ipv6SelectedCidr?: string;\n\n  /**\n   * Subnet configurations for this VPC\n   */\n  private subnetConfiguration: SubnetConfiguration[] = [];\n\n  private readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  /**\n   * Vpc creates a VPC that spans a whole region.\n   * It will automatically divide the provided VPC CIDR range, and create public and private subnets per Availability Zone.\n   * Network routing for the public subnets will be configured to allow outbound access directly via an Internet Gateway.\n   * Network routing for the private subnets will be configured to allow outbound access via a set of resilient NAT Gateways (one per AZ).\n   */\n  constructor(scope: Construct, id: string, props: VpcProps = {}) {\n    super(scope, id);\n\n    const stack = this.stack;\n\n    // Can't have enabledDnsHostnames without enableDnsSupport\n    if (props.enableDnsHostnames && !props.enableDnsSupport) {\n      throw new Error(\n        \"To use DNS Hostnames, DNS Support must be enabled, however, it was explicitly disabled.\",\n      );\n    }\n\n    if (props.availabilityZones && props.maxAzs) {\n      throw new Error(\n        \"Vpc supports 'availabilityZones' or 'maxAzs', but not both.\",\n      );\n    }\n\n    const cidrBlock = ifUndefined(props.cidr, Vpc.DEFAULT_CIDR_RANGE);\n    if (Token.isUnresolved(cidrBlock)) {\n      throw new Error(\n        \"'cidr' property must be a concrete CIDR string, got a Token (we need to parse it for automatic subdivision)\",\n      );\n    }\n\n    if (props.ipAddresses && props.cidr) {\n      throw new Error(\"supply at most one of ipAddresses or cidr\");\n    }\n\n    const ipProtocol = props.ipProtocol ?? IpProtocol.IPV4_ONLY;\n    // this property can be set to false if an IPv6_ONLY VPC is implemented in the future\n    this.useIpv4 =\n      ipProtocol === IpProtocol.IPV4_ONLY ||\n      ipProtocol === IpProtocol.DUAL_STACK;\n\n    this.useIpv6 = ipProtocol === IpProtocol.DUAL_STACK;\n\n    const ipv6OnlyProps: Array<keyof VpcProps> = [\"ipv6Addresses\"];\n    if (!this.useIpv6) {\n      for (const prop of ipv6OnlyProps) {\n        if (props[prop] !== undefined) {\n          throw new Error(\n            `${prop} can only be set if IPv6 is enabled. Set ipProtocol to DUAL_STACK`,\n          );\n        }\n      }\n    }\n\n    this.ipAddresses = props.ipAddresses ?? IpAddresses.cidr(cidrBlock);\n\n    this.dnsHostnamesEnabled =\n      props.enableDnsHostnames == null ? true : props.enableDnsHostnames;\n    this.dnsSupportEnabled =\n      props.enableDnsSupport == null ? true : props.enableDnsSupport;\n    const instanceTenancy = props.defaultInstanceTenancy || \"default\";\n    this.internetConnectivityEstablished =\n      this._internetConnectivityEstablished;\n\n    const vpcIpAddressOptions = this.ipAddresses.allocateVpcCidr();\n\n    // Define a VPC using the provided CIDR range\n    this.resource = new vpc.Vpc(this, \"Resource\", {\n      cidrBlock: vpcIpAddressOptions.cidrBlock,\n      ipv4IpamPoolId: vpcIpAddressOptions.ipv4IpamPoolId,\n      ipv4NetmaskLength: vpcIpAddressOptions.ipv4NetmaskLength,\n      enableDnsHostnames: this.dnsHostnamesEnabled,\n      enableDnsSupport: this.dnsSupportEnabled,\n      instanceTenancy,\n    });\n\n    this.vpcDefaultNetworkAcl = this.resource.defaultNetworkAclId;\n    this.vpcCidrBlock = this.resource.cidrBlock;\n    this.vpcDefaultSecurityGroup = this.resource.defaultSecurityGroupId;\n    this.vpcIpv6CidrBlock = this.resource.ipv6CidrBlock;\n    // this.vpcCidrBlockAssociations = this.resource.cidrBlockAssociations;\n\n    Tags.of(this).add(NAME_TAG, props.vpcName || this.node.path);\n\n    if (props.availabilityZones) {\n      // TODO: Implement ContextProvider to validate AZs\n      // // If given AZs and stack AZs are both resolved, then validate their compatibility.\n      // const resolvedStackAzs = this.resolveStackAvailabilityZones(\n      //   stack.availabilityZones(props.maxAzs),\n      // );\n      // const areGivenAzsSubsetOfStack =\n      //   resolvedStackAzs.length === 0 ||\n      //   props.availabilityZones.every(\n      //     (az) => Token.isUnresolved(az) || resolvedStackAzs.includes(az),\n      //   );\n      // if (!areGivenAzsSubsetOfStack) {\n      //   throw new Error(\n      //     `Given VPC 'availabilityZones' ${props.availabilityZones} must be a subset of the stack's availability zones ${resolvedStackAzs}`,\n      //   );\n      // }\n      this.availabilityZones = props.availabilityZones;\n    } else {\n      const maxAZs = props.maxAzs ?? 3;\n      this.availabilityZones = stack.availabilityZones(maxAZs);\n    }\n    for (let i = 0; props.reservedAzs && i < props.reservedAzs; i++) {\n      this.availabilityZones.push(FAKE_AZ_NAME);\n    }\n\n    this.vpcId = this.resource.id;\n    this.vpcArn = Arn.format(\n      {\n        service: \"ec2\",\n        resource: \"vpc\",\n        resourceName: this.vpcId,\n      },\n      stack,\n    );\n\n    const defaultSubnet =\n      props.natGateways === 0\n        ? Vpc.DEFAULT_SUBNETS_NO_NAT\n        : Vpc.DEFAULT_SUBNETS;\n    this.subnetConfiguration = ifUndefined(\n      props.subnetConfiguration,\n      defaultSubnet,\n    );\n\n    const natGatewayPlacement = props.natGatewaySubnets || {\n      subnetType: SubnetType.PUBLIC,\n    };\n    const natGatewayCount = determineNatGatewayCount(\n      props.natGateways,\n      this.subnetConfiguration,\n      this.availabilityZones.length,\n    );\n\n    if (this.useIpv6) {\n      this.ipv6Addresses =\n        props.ipv6Addresses ?? Ipv6Addresses.amazonProvided();\n\n      this.ipv6CidrBlock = this.ipv6Addresses.allocateVpcIpv6Cidr({\n        scope: this,\n        vpcId: this.vpcId,\n      });\n\n      // TODO: how to allow ipv6 cidr block inputs?\n      this.ipv6SelectedCidr = this.resource.ipv6CidrBlock;\n    }\n\n    // subnetConfiguration must be set before calling createSubnets\n    this.createSubnets();\n\n    const createInternetGateway = props.createInternetGateway ?? true;\n    const allowOutbound =\n      this.subnetConfiguration.filter(\n        (sn) =>\n          sn.subnetType !== SubnetType.PRIVATE_ISOLATED &&\n          sn.subnetType !== SubnetType.ISOLATED &&\n          !sn.reserved,\n      ).length > 0;\n\n    // Create an Internet Gateway and attach it if necessary\n    if (allowOutbound && createInternetGateway) {\n      const igw = new internetGateway.InternetGateway(this, \"IGW\", {});\n\n      this.internetGatewayId = igw.id;\n\n      this._internetConnectivityEstablished.add(igw);\n      const att = new internetGatewayAttachment.InternetGatewayAttachment(\n        this,\n        \"VPCGW\",\n        {\n          internetGatewayId: igw.id,\n          vpcId: this.resource.id,\n        },\n      );\n\n      (this.publicSubnets as PublicSubnet[]).forEach((publicSubnet) => {\n        // configure IPv4 route\n        if (this.useIpv4) {\n          publicSubnet.addDefaultInternetRoute(igw.id, att);\n        }\n        // configure IPv6 route if VPC is dual stack\n        if (this.useIpv6) {\n          publicSubnet.addIpv6DefaultInternetRoute(igw.id);\n        }\n      });\n\n      // if gateways are needed create them\n      if (natGatewayCount > 0) {\n        const provider = props.natGatewayProvider || NatProvider.gateway();\n        this.createNatGateways(provider, natGatewayCount, natGatewayPlacement);\n      }\n    }\n\n    // Create an Egress Only Internet Gateway and attach it if necessary\n    if (this.useIpv6 && this.privateSubnets) {\n      const eigw = new egressOnlyInternetGateway.EgressOnlyInternetGateway(\n        this,\n        \"EIGW6\",\n        {\n          vpcId: this.vpcId,\n        },\n      );\n\n      (this.privateSubnets as PrivateSubnet[]).forEach((privateSubnet) => {\n        privateSubnet.addIpv6DefaultEgressOnlyInternetRoute(eigw.id);\n      });\n    }\n\n    if (\n      props.vpnGateway &&\n      this.publicSubnets.length === 0 &&\n      this.privateSubnets.length === 0 &&\n      this.isolatedSubnets.length === 0\n    ) {\n      throw new Error(\n        \"Can not enable the VPN gateway while the VPC has no subnets at all\",\n      );\n    }\n\n    if (\n      (props.vpnConnections || props.vpnGatewayAsn) &&\n      props.vpnGateway === false\n    ) {\n      throw new Error(\n        \"Cannot specify `vpnConnections` or `vpnGatewayAsn` when `vpnGateway` is set to false.\",\n      );\n    }\n\n    if (props.vpnGateway || props.vpnConnections || props.vpnGatewayAsn) {\n      this.enableVpnGateway({\n        amazonSideAsn: props.vpnGatewayAsn,\n        type: VpnConnectionType.IPSEC_1,\n        vpnRoutePropagation: props.vpnRoutePropagation,\n      });\n\n      const vpnConnections = props.vpnConnections || {};\n      for (const [connectionId, connection] of Object.entries(vpnConnections)) {\n        this.addVpnConnection(connectionId, connection);\n      }\n    }\n\n    // Allow creation of gateway endpoints on VPC instantiation as those can be\n    // immediately functional without further configuration. This is not the case\n    // for interface endpoints where the security group must be configured.\n    if (props.gatewayEndpoints) {\n      const gatewayEndpoints = props.gatewayEndpoints || {};\n      for (const [endpointId, endpoint] of Object.entries(gatewayEndpoints)) {\n        this.addGatewayEndpoint(endpointId, endpoint);\n      }\n    }\n\n    // Add flow logs to the VPC\n    if (props.flowLogs) {\n      const flowLogs = props.flowLogs || {};\n      for (const [flowLogId, flowLog] of Object.entries(flowLogs)) {\n        this.addFlowLog(flowLogId, flowLog);\n      }\n    }\n\n    /**\n     * Enable this feature flag to remove the default ingress/egress rules from the\n     * VPC default security group.\n     *\n     * When a VPC is created, a default security group is created as well and this cannot\n     * be deleted. The default security group is created with ingress/egress rules that allow\n     * _all_ traffic. [AWS Security best practices recommend](https://docs.aws.amazon.com/securityhub/latest/userguide/ec2-controls.html#ec2-2)\n     * removing these ingress/egress rules in order to restrict access to the default security group.\n     */\n    // const restrictFlag = FeatureFlags.of(this).isEnabled(\n    //   EC2_RESTRICT_DEFAULT_SECURITY_GROUP,\n    // );\n    // if (\n    //   (restrictFlag && props.restrictDefaultSecurityGroup !== false) ||\n    //   props.restrictDefaultSecurityGroup\n    // ) {\n    //   this.restrictDefaultSecurityGroup();\n    // }\n  }\n\n  /**\n   * Adds a new S3 gateway endpoint to this VPC\n   *\n   * @deprecated use `addGatewayEndpoint()` instead\n   */\n  public addS3Endpoint(\n    id: string,\n    subnets?: SubnetSelection[],\n  ): GatewayVpcEndpoint {\n    return new GatewayVpcEndpoint(this, id, {\n      service: GatewayVpcEndpointAwsService.S3,\n      vpc: this,\n      subnets,\n    });\n  }\n\n  /**\n   * Adds a new DynamoDB gateway endpoint to this VPC\n   *\n   * @deprecated use `addGatewayEndpoint()` instead\n   */\n  public addDynamoDbEndpoint(\n    id: string,\n    subnets?: SubnetSelection[],\n  ): GatewayVpcEndpoint {\n    return new GatewayVpcEndpoint(this, id, {\n      service: GatewayVpcEndpointAwsService.DYNAMODB,\n      vpc: this,\n      subnets,\n    });\n  }\n\n  private createNatGateways(\n    provider: NatProvider,\n    natCount: number,\n    placement: SubnetSelection,\n  ): void {\n    const natSubnets: PublicSubnet[] = this.selectSubnetObjects(\n      placement,\n    ) as PublicSubnet[];\n    for (const sub of natSubnets) {\n      if (this.publicSubnets.indexOf(sub) === -1) {\n        throw new Error(\n          `natGatewayPlacement ${placement} contains non public subnet ${sub}`,\n        );\n      }\n    }\n\n    provider.configureNat({\n      vpc: this,\n      natSubnets: natSubnets.slice(0, natCount),\n      privateSubnets: this.privateSubnets as PrivateSubnet[],\n    });\n  }\n\n  /**\n   * createSubnets creates the subnets specified by the subnet configuration\n   * array or creates the `DEFAULT_SUBNETS` configuration\n   */\n  private createSubnets() {\n    const requestedSubnets: RequestedSubnet[] = [];\n\n    this.subnetConfiguration.forEach((configuration) =>\n      this.availabilityZones.forEach((az, index) => {\n        requestedSubnets.push({\n          availabilityZone: az,\n          subnetConstructId: subnetId(configuration.name, index),\n          configuration,\n        });\n      }),\n    );\n\n    let { allocatedSubnets } = this.ipAddresses.allocateSubnetsCidr({\n      vpcCidr: this.vpcCidrBlock,\n      requestedSubnets,\n    });\n\n    if (allocatedSubnets.length != requestedSubnets.length) {\n      throw new Error(\n        \"Incomplete Subnet Allocation; response array dose not equal input array\",\n      );\n    }\n\n    if (this.useIpv6) {\n      if (this.ipv6SelectedCidr === undefined) {\n        throw new Error(\n          \"No IPv6 CIDR block associated with this VPC could be found\",\n        );\n      }\n      if (this.ipv6Addresses === undefined) {\n        throw new Error(\"No IPv6 IpAddresses were found\");\n      }\n      // create the IPv6 CIDR blocks\n      const subnetIpv6Cidrs = this.ipv6Addresses.createIpv6CidrBlocks({\n        ipv6SelectedCidr: this.ipv6SelectedCidr,\n        subnetCount: allocatedSubnets.length,\n      });\n\n      // copy the list of allocated subnets while assigning the IPv6 CIDR\n      const allocatedSubnetsIpv6 = this.ipv6Addresses.allocateSubnetsIpv6Cidr({\n        allocatedSubnets: allocatedSubnets,\n        ipv6Cidrs: subnetIpv6Cidrs,\n      });\n\n      // assign allocated subnets to list with IPv6 addresses\n      allocatedSubnets = allocatedSubnetsIpv6.allocatedSubnets;\n    }\n\n    this.createSubnetResources(requestedSubnets, allocatedSubnets);\n\n    if (this.useIpv6) {\n      // add dependencies\n      (this.publicSubnets as PublicSubnet[]).forEach((publicSubnet) => {\n        if (this.ipv6CidrBlock !== undefined) {\n          publicSubnet.node.addDependency(this.ipv6CidrBlock);\n        }\n      });\n      (this.privateSubnets as PrivateSubnet[]).forEach((privateSubnet) => {\n        if (this.ipv6CidrBlock !== undefined) {\n          privateSubnet.node.addDependency(this.ipv6CidrBlock);\n        }\n      });\n      (this.isolatedSubnets as PrivateSubnet[]).forEach((isolatedSubnet) => {\n        if (this.ipv6CidrBlock !== undefined) {\n          isolatedSubnet.node.addDependency(this.ipv6CidrBlock);\n        }\n      });\n    }\n  }\n\n  /**\n   * Defaults to true in Subnet.Public for IPV4_ONLY VPCs.\n   *\n   * Defaults to false in Subnet.Public for DUAL_STACK VPCs.\n   *\n   * Always defaults to false in non-public subnets and will error if set.\n   */\n  private calculateMapPublicIpOnLaunch(subnetConfig: SubnetConfiguration) {\n    if (subnetConfig.subnetType === SubnetType.PUBLIC) {\n      return subnetConfig.mapPublicIpOnLaunch !== undefined\n        ? subnetConfig.mapPublicIpOnLaunch\n        : !this.useIpv6; // changes default based on protocol of vpc\n    } else {\n      if (subnetConfig.mapPublicIpOnLaunch !== undefined) {\n        throw new Error(\n          `${subnetConfig.subnetType} subnet cannot include mapPublicIpOnLaunch parameter`,\n        );\n      }\n      return false;\n    }\n  }\n\n  private createSubnetResources(\n    requestedSubnets: RequestedSubnet[],\n    allocatedSubnets: AllocatedSubnet[],\n  ) {\n    allocatedSubnets.forEach((allocated, i) => {\n      const {\n        configuration: subnetConfig,\n        subnetConstructId,\n        availabilityZone,\n      } = requestedSubnets[i];\n\n      if (subnetConfig.reserved === true) {\n        // For reserved subnets, do not create any resources\n        return;\n      }\n      if (availabilityZone === FAKE_AZ_NAME) {\n        // For reserved azs, do not create any resources\n        return;\n      }\n\n      const ipv6OnlyProps: Array<keyof SubnetConfiguration> = [\n        \"ipv6AssignAddressOnCreation\",\n      ];\n      if (!this.useIpv6) {\n        for (const prop of ipv6OnlyProps) {\n          if (subnetConfig[prop] !== undefined) {\n            throw new Error(\n              `${prop} can only be set if IPv6 is enabled. Set ipProtocol to DUAL_STACK`,\n            );\n          }\n        }\n      }\n\n      const subnetProps = {\n        availabilityZone,\n        vpcId: this.vpcId,\n        cidrBlock: allocated.cidr,\n        mapPublicIpOnLaunch: this.calculateMapPublicIpOnLaunch(subnetConfig),\n        ipv6CidrBlock: allocated.ipv6Cidr,\n        assignIpv6AddressOnCreation: this.useIpv6\n          ? (subnetConfig.ipv6AssignAddressOnCreation ?? true)\n          : undefined,\n      } satisfies SubnetProps;\n\n      let sn: Subnet;\n      switch (subnetConfig.subnetType) {\n        case SubnetType.PUBLIC:\n          const publicSubnet = new PublicSubnet(\n            this,\n            subnetConstructId,\n            subnetProps,\n          );\n          this.publicSubnets.push(publicSubnet);\n          sn = publicSubnet;\n          break;\n        case SubnetType.PRIVATE_WITH_EGRESS:\n        case SubnetType.PRIVATE_WITH_NAT:\n        case SubnetType.PRIVATE:\n          const privateSubnet = new PrivateSubnet(\n            this,\n            subnetConstructId,\n            subnetProps,\n          );\n          this.privateSubnets.push(privateSubnet);\n          sn = privateSubnet;\n          break;\n        case SubnetType.PRIVATE_ISOLATED:\n        case SubnetType.ISOLATED:\n          const isolatedSubnet = new PrivateSubnet(\n            this,\n            subnetConstructId,\n            subnetProps,\n          );\n          this.isolatedSubnets.push(isolatedSubnet);\n          sn = isolatedSubnet;\n          break;\n        default:\n          throw new Error(\n            `Unrecognized subnet type: ${subnetConfig.subnetType}`,\n          );\n      }\n\n      // These values will be used to recover the config upon provider import\n      const includeResourceTypes = [subnet.Subnet.tfResourceType];\n      Tags.of(sn).add(SUBNETNAME_TAG, subnetConfig.name, {\n        includeResourceTypes,\n      });\n      Tags.of(sn).add(\n        SUBNETTYPE_TAG,\n        subnetTypeTagValue(subnetConfig.subnetType),\n        { includeResourceTypes },\n      );\n    });\n  }\n\n  // // TODO: Add custom resources support\n  // private restrictDefaultSecurityGroup(): void {\n  //   const id = \"Custom::VpcRestrictDefaultSG\";\n  //   const provider = RestrictDefaultSgProvider.getOrCreateProvider(this, id, {\n  //     description:\n  //       \"Lambda function for removing all inbound/outbound rules from the VPC default security group\",\n  //   });\n  //   provider.addToRolePolicy({\n  //     Effect: \"Allow\",\n  //     Action: [\n  //       \"ec2:AuthorizeSecurityGroupIngress\",\n  //       \"ec2:AuthorizeSecurityGroupEgress\",\n  //       \"ec2:RevokeSecurityGroupIngress\",\n  //       \"ec2:RevokeSecurityGroupEgress\",\n  //     ],\n  //     Resource: [\n  //       AwsStack.ofAwsConstruct(this).formatArn({\n  //         resource: \"security-group\",\n  //         service: \"ec2\",\n  //         resourceName: this.vpcDefaultSecurityGroup,\n  //       }),\n  //     ],\n  //   });\n  //   new CustomResource(this, \"RestrictDefaultSecurityGroupCustomResource\", {\n  //     resourceType: id,\n  //     serviceToken: provider.serviceToken,\n  //     properties: {\n  //       DefaultSecurityGroupId: this.vpcDefaultSecurityGroup,\n  //       Account: AwsStack.ofAwsConstruct(this).account,\n  //     },\n  //   });\n  // }\n\n  // /**\n  //  * Returns the list of resolved availability zones found in the provided stack availability\n  //  * zones.\n  //  *\n  //  * Note: A resolved availability zone refers to an availability zone that is not a token\n  //  * and is also not a dummy value.\n  //  */\n  // private resolveStackAvailabilityZones(\n  //   stackAvailabilityZones: string[],\n  // ): string[] {\n  //   const dummyValues = [\"dummy1a\", \"dummy1b\", \"dummy1c\"];\n  //   // if an az is resolved and it is not a 'dummy' value, then add it to array as a resolved az\n  //   return stackAvailabilityZones.filter(\n  //     (az) => !Token.isUnresolved(az) && !dummyValues.includes(az),\n  //   );\n  // }\n}\n\nconst SUBNETTYPE_TAG = \"aws-cdk:subnet-type\";\nconst SUBNETNAME_TAG = \"aws-cdk:subnet-name\";\n\nfunction subnetTypeTagValue(type: SubnetType) {\n  switch (type) {\n    case SubnetType.PUBLIC:\n      return \"Public\";\n    case SubnetType.PRIVATE_WITH_EGRESS:\n    case SubnetType.PRIVATE_WITH_NAT:\n    case SubnetType.PRIVATE:\n      return \"Private\";\n    case SubnetType.PRIVATE_ISOLATED:\n    case SubnetType.ISOLATED:\n      return \"Isolated\";\n  }\n}\n\n/**\n * Specify configuration parameters for a VPC subnet\n */\nexport interface SubnetProps {\n  /**\n   * The availability zone for the subnet\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The VPC which this subnet is part of\n   */\n  readonly vpcId: string;\n\n  /**\n   * The CIDR notation for this subnet\n   */\n  readonly cidrBlock: string;\n\n  /**\n   * Controls if a public IP is associated to an instance at launch\n   *\n   * @default true in Subnet.Public, false in Subnet.Private or Subnet.Isolated.\n   */\n  readonly mapPublicIpOnLaunch?: boolean;\n\n  /**\n   * The IPv6 CIDR block.\n   *\n   * If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.\n   *\n   * @default - no IPv6 CIDR block.\n   */\n  readonly ipv6CidrBlock?: string;\n\n  /**\n   * Indicates whether a network interface created in this subnet receives an IPv6 address.\n   *\n   * If you specify AssignIpv6AddressOnCreation, you must also specify Ipv6CidrBlock.\n   *\n   * @default false\n   */\n  readonly assignIpv6AddressOnCreation?: boolean;\n}\n\n/**\n * Represents a new VPC subnet resource\n *\n * @resource aws_subnet\n */\nexport class Subnet extends AwsConstructBase implements ISubnet {\n  public static isVpcSubnet(x: any): x is Subnet {\n    return VPC_SUBNET_SYMBOL in x;\n  }\n\n  public static fromSubnetAttributes(\n    scope: Construct,\n    id: string,\n    attrs: SubnetAttributes,\n  ): ISubnet {\n    return new ImportedSubnet(scope, id, attrs);\n  }\n\n  /**\n   * Import existing subnet from id.\n   */\n  public static fromSubnetId(\n    scope: Construct,\n    id: string,\n    // eslint-disable-next-line @typescript-eslint/no-shadow\n    subnetId: string,\n  ): ISubnet {\n    return this.fromSubnetAttributes(scope, id, { subnetId });\n  }\n\n  public readonly subnetOutputs: SubnetOutputs;\n  public get outputs(): Record<string, any> {\n    return this.subnetOutputs;\n  }\n\n  /**\n   * The Availability Zone the subnet is located in\n   */\n  public readonly availabilityZone: string;\n\n  /**\n   * @attribute\n   */\n  public readonly ipv4CidrBlock: string;\n\n  /**\n   * The subnetId for this particular subnet\n   */\n  public readonly subnetId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly subnetVpcId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly subnetAvailabilityZone: string;\n\n  // TODO: use aws_subnet_ipv6_cidr_block_association sub resources?\n  // /**\n  //  * @attribute\n  //  */\n  // public readonly subnetIpv6CidrBlocks: string[];\n\n  /**\n   * @attribute\n   */\n  public readonly subnetIpv6CidrBlock: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the Outpost for this subnet (if one exists).\n   * @attribute\n   */\n  public readonly subnetOutpostArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly subnetNetworkAclAssociationId: string | undefined;\n\n  /**\n   * Parts of this VPC subnet\n   */\n  public readonly dependencyElements: IDependable[] = [];\n\n  /**\n   * The routeTableId attached to this subnet.\n   */\n  public readonly routeTable: IRouteTable;\n\n  public readonly internetConnectivityEstablished: IDependable;\n\n  private readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  private _networkAcl?: INetworkAcl;\n  public resource: subnet.Subnet;\n\n  constructor(scope: Construct, id: string, props: SubnetProps) {\n    super(scope, id);\n\n    Object.defineProperty(this, VPC_SUBNET_SYMBOL, { value: true });\n\n    Tags.of(this).add(NAME_TAG, this.node.path);\n\n    this.availabilityZone = props.availabilityZone;\n    this.ipv4CidrBlock = props.cidrBlock;\n    this.resource = new subnet.Subnet(this, \"Resource\", {\n      vpcId: props.vpcId,\n      cidrBlock: props.cidrBlock,\n      availabilityZone: props.availabilityZone,\n      mapPublicIpOnLaunch: props.mapPublicIpOnLaunch,\n      ipv6CidrBlock: props.ipv6CidrBlock,\n      assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation,\n    });\n    this.subnetId = this.resource.id;\n    this.subnetVpcId = this.resource.vpcId;\n    this.subnetAvailabilityZone = this.resource.availabilityZone;\n    // TODO: Support IPv6 Association blocks\n    this.subnetIpv6CidrBlock = this.resource.ipv6CidrBlock;\n    this.subnetOutpostArn = this.resource.outpostArn;\n\n    // Terraform subnet does not provide the default ACL NetworkAclAssociationId attribute\n    // // subnet.NetworkAclAssociationId is the default ACL after the subnet\n    // // was just created. However, the ACL can be replaced at a later time.\n    // this._networkAcl = NetworkAcl.fromNetworkAclId(\n    //   this,\n    //   \"Acl\",\n    //   this.resource.NetworkAclAssociationId,\n    // );\n    this.subnetNetworkAclAssociationId = Lazy.stringValue({\n      produce: () => this._networkAcl?.networkAclId ?? Token.asString(null),\n    });\n\n    const table = new routeTable.RouteTable(this, \"RouteTable\", {\n      vpcId: props.vpcId,\n    });\n    this.routeTable = { routeTableId: table.id };\n\n    // Associate the public route table for this subnet, to this subnet\n    const routeAssoc = new routeTableAssociation.RouteTableAssociation(\n      this,\n      \"RouteTableAssociation\",\n      {\n        subnetId: this.subnetId,\n        routeTableId: table.id,\n      },\n    );\n    this._internetConnectivityEstablished.add(routeAssoc);\n\n    this.internetConnectivityEstablished =\n      this._internetConnectivityEstablished;\n    this.subnetOutputs = {\n      subnetId: this.subnetId,\n      ipv4CidrBlock: this.ipv4CidrBlock,\n      routeTableId: this.routeTable.routeTableId,\n    };\n  }\n\n  /**\n   * Create a default route that points to a passed IGW, with a dependency\n   * on the IGW's attachment to the VPC.\n   *\n   * @param gatewayId the logical ID (ref) of the gateway attached to your VPC\n   * @param gatewayAttachment the gateway attachment construct to be added as a dependency\n   */\n  public addDefaultInternetRoute(\n    gatewayId: string,\n    gatewayAttachment: IDependable,\n  ) {\n    const r = new route.Route(this, \"DefaultRoute\", {\n      routeTableId: this.routeTable.routeTableId,\n      destinationCidrBlock: \"0.0.0.0/0\",\n      gatewayId,\n    });\n    r.node.addDependency(gatewayAttachment);\n\n    // Since the 'r' depends on the gateway attachment, just\n    // depending on the route is enough.\n    this._internetConnectivityEstablished.add(r);\n  }\n\n  /**\n   * Create a default IPv6 route that points to a passed IGW.\n   *\n   * @param gatewayId the logical ID (ref) of the gateway attached to your VPC\n   */\n  public addIpv6DefaultInternetRoute(gatewayId: string) {\n    this.addRoute(\"DefaultRoute6\", {\n      routerType: RouterType.GATEWAY,\n      routerId: gatewayId,\n      destinationIpv6CidrBlock: \"::/0\",\n      enablesInternetConnectivity: true,\n    });\n  }\n\n  /**\n   * Create a default IPv6 route that points to a passed EIGW.\n   *\n   * @param gatewayId the logical ID (ref) of the gateway attached to your VPC\n   */\n  public addIpv6DefaultEgressOnlyInternetRoute(gatewayId: string) {\n    this.addRoute(\"DefaultRoute6\", {\n      routerType: RouterType.EGRESS_ONLY_INTERNET_GATEWAY,\n      routerId: gatewayId,\n      destinationIpv6CidrBlock: \"::/0\",\n      enablesInternetConnectivity: true,\n    });\n  }\n\n  /**\n   * Network ACL associated with this Subnet\n   *\n   * Upon creation, this is undefined pointing to\n   * the default ACL which allows all traffic, except\n   * explicit DENY entries that you add.\n   *\n   * You can replace it with a custom ACL which denies all traffic except\n   * the explicit ALLOW entries that you add by creating a `NetworkAcl`\n   * object and calling `associateNetworkAcl()`.\n   */\n  public get networkAcl(): INetworkAcl | undefined {\n    return this._networkAcl;\n  }\n\n  /**\n   * Adds an entry to this subnets route table that points to the passed NATGatewayId\n   * @param natGatewayId The ID of the NAT gateway\n   */\n  public addDefaultNatRoute(natGatewayId: string) {\n    this.addRoute(\"DefaultRoute\", {\n      routerType: RouterType.NAT_GATEWAY,\n      routerId: natGatewayId,\n      enablesInternetConnectivity: true,\n    });\n  }\n\n  /**\n   * Adds an entry to this subnets route table that points to the passed NATGatewayId.\n   * Uses the known 64:ff9b::/96 prefix.\n   * @param natGatewayId The ID of the NAT gateway\n   */\n  public addIpv6Nat64Route(natGatewayId: string) {\n    this.addRoute(\"Nat64\", {\n      routerType: RouterType.NAT_GATEWAY,\n      routerId: natGatewayId,\n      enablesInternetConnectivity: true,\n      destinationIpv6CidrBlock: \"64:ff9b::/96\",\n    });\n  }\n\n  /**\n   * Adds an entry to this subnets route table\n   */\n  public addRoute(id: string, options: AddRouteOptions) {\n    if (options.destinationCidrBlock && options.destinationIpv6CidrBlock) {\n      throw new Error(\n        \"Cannot specify both 'destinationCidrBlock' and 'destinationIpv6CidrBlock'\",\n      );\n    }\n\n    const r = new route.Route(this, id, {\n      routeTableId: this.routeTable.routeTableId,\n      destinationCidrBlock:\n        options.destinationCidrBlock ||\n        (options.destinationIpv6CidrBlock === undefined\n          ? \"0.0.0.0/0\"\n          : undefined),\n      destinationIpv6CidrBlock: options.destinationIpv6CidrBlock,\n      [routerTypeToPropName(options.routerType)]: options.routerId,\n    });\n\n    if (options.enablesInternetConnectivity) {\n      this._internetConnectivityEstablished.add(r);\n    }\n  }\n\n  public associateNetworkAcl(id: string, networkAcl: INetworkAcl) {\n    this._networkAcl = networkAcl;\n\n    const scope = networkAcl instanceof Construct ? networkAcl : this;\n    const other = networkAcl instanceof Construct ? this : networkAcl;\n    new SubnetNetworkAclAssociation(scope, id + AwsStack.uniqueId(other.node), {\n      networkAcl,\n      subnet: this,\n    });\n  }\n}\n\n/**\n * Options for adding a new route to a subnet\n */\nexport interface AddRouteOptions {\n  /**\n   * IPv4 range this route applies to\n   *\n   * @default '0.0.0.0/0'\n   */\n  readonly destinationCidrBlock?: string;\n\n  /**\n   * IPv6 range this route applies to\n   *\n   * @default - Uses IPv6\n   */\n  readonly destinationIpv6CidrBlock?: string;\n\n  /**\n   * What type of router to route this traffic to\n   */\n  readonly routerType: RouterType;\n\n  /**\n   * The ID of the router\n   *\n   * Can be an instance ID, gateway ID, etc, depending on the router type.\n   */\n  readonly routerId: string;\n\n  /**\n   * Whether this route will enable internet connectivity\n   *\n   * If true, this route will be added before any AWS resources that depend\n   * on internet connectivity in the VPC will be created.\n   *\n   * @default false\n   */\n  readonly enablesInternetConnectivity?: boolean;\n}\n\n/**\n * Type of router used in route\n */\nexport enum RouterType {\n  /**\n   * Carrier gateway\n   */\n  CARRIER_GATEWAY = \"CarrierGateway\",\n\n  /**\n   * Egress-only Internet Gateway\n   */\n  EGRESS_ONLY_INTERNET_GATEWAY = \"EgressOnlyInternetGateway\",\n\n  /**\n   * Internet Gateway\n   */\n  GATEWAY = \"Gateway\",\n\n  // /**\n  //  * Instance\n  //  */\n  // INSTANCE = \"Instance\",\n\n  /**\n   * Local Gateway\n   */\n  LOCAL_GATEWAY = \"LocalGateway\",\n\n  /**\n   * NAT Gateway\n   */\n  NAT_GATEWAY = \"NatGateway\",\n\n  /**\n   * Network Interface\n   */\n  NETWORK_INTERFACE = \"NetworkInterface\",\n\n  /**\n   * Transit Gateway\n   */\n  TRANSIT_GATEWAY = \"TransitGateway\",\n\n  /**\n   * VPC peering connection\n   */\n  VPC_PEERING_CONNECTION = \"VpcPeeringConnection\",\n\n  /**\n   * VPC Endpoint for gateway load balancers\n   */\n  VPC_ENDPOINT = \"VpcEndpoint\",\n}\n\n/**\n * inverse of\n * https://github.com/hashicorp/terraform-provider-aws/blob/v5.87.0/internal/service/ec2/vpc_route.go#L219-L239\n */\nfunction routerTypeToPropName(routerType: RouterType) {\n  const lookupMap: Record<RouterType, keyof route.RouteConfig> = {\n    [RouterType.CARRIER_GATEWAY]: \"carrierGatewayId\",\n    [RouterType.EGRESS_ONLY_INTERNET_GATEWAY]: \"egressOnlyGatewayId\",\n    [RouterType.GATEWAY]: \"gatewayId\",\n    // terraform-provider-aws is missing switch case for InstanceId\n    // https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateRoute.html\n    // [RouterType.INSTANCE]: \"instanceId\",\n    [RouterType.LOCAL_GATEWAY]: \"localGatewayId\",\n    [RouterType.NAT_GATEWAY]: \"natGatewayId\",\n    [RouterType.NETWORK_INTERFACE]: \"networkInterfaceId\",\n    [RouterType.TRANSIT_GATEWAY]: \"transitGatewayId\",\n    [RouterType.VPC_PEERING_CONNECTION]: \"vpcPeeringConnectionId\",\n    [RouterType.VPC_ENDPOINT]: \"vpcEndpointId\",\n  };\n  return lookupMap[routerType];\n}\n\nexport interface PublicSubnetProps extends SubnetProps {}\n\nexport interface IPublicSubnet extends ISubnet {}\n\nexport interface PublicSubnetAttributes extends SubnetAttributes {}\n\n/**\n * Represents a public VPC subnet resource\n */\nexport class PublicSubnet extends Subnet implements IPublicSubnet {\n  public static fromPublicSubnetAttributes(\n    scope: Construct,\n    id: string,\n    attrs: PublicSubnetAttributes,\n  ): IPublicSubnet {\n    return new ImportedSubnet(scope, id, attrs);\n  }\n\n  constructor(scope: Construct, id: string, props: PublicSubnetProps) {\n    super(scope, id, props);\n  }\n\n  /**\n   * Creates a new managed NAT gateway attached to this public subnet.\n   * Also adds the EIP for the managed NAT.\n   * @returns A ref to the the NAT Gateway ID\n   */\n  public addNatGateway(eipAllocationId?: string) {\n    // Create a NAT Gateway in this public subnet\n    const ngw = new natGateway.NatGateway(this, \"NATGateway\", {\n      subnetId: this.subnetId,\n      allocationId:\n        eipAllocationId ??\n        new eip.Eip(this, \"EIP\", {\n          domain: \"vpc\",\n        }).allocationId,\n    });\n    ngw.node.addDependency(this.internetConnectivityEstablished);\n    return ngw;\n  }\n}\n\nexport interface PrivateSubnetProps extends SubnetProps {}\n\nexport interface IPrivateSubnet extends ISubnet {}\n\nexport interface PrivateSubnetAttributes extends SubnetAttributes {}\n\n/**\n * Represents a private VPC subnet resource\n */\nexport class PrivateSubnet extends Subnet implements IPrivateSubnet {\n  public static fromPrivateSubnetAttributes(\n    scope: Construct,\n    id: string,\n    attrs: PrivateSubnetAttributes,\n  ): IPrivateSubnet {\n    return new ImportedSubnet(scope, id, attrs);\n  }\n\n  constructor(scope: Construct, id: string, props: PrivateSubnetProps) {\n    super(scope, id, props);\n  }\n}\n\nfunction ifUndefined<T>(value: T | undefined, defaultValue: T): T {\n  return value ?? defaultValue;\n}\n\nclass ImportedVpc extends VpcBase {\n  public readonly vpcId: string;\n  public readonly vpcArn: string;\n  public readonly publicSubnets: ISubnet[];\n  public readonly privateSubnets: ISubnet[];\n  public readonly isolatedSubnets: ISubnet[];\n  public readonly availabilityZones: string[];\n  public readonly internetConnectivityEstablished: IDependable =\n    new DependencyGroup();\n  private readonly cidr?: string | undefined;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: VpcAttributes,\n    isIncomplete: boolean,\n  ) {\n    super(scope, id, {\n      region: props.region,\n    });\n\n    this.vpcId = props.vpcId;\n    this.vpcArn = Arn.format(\n      {\n        service: \"ec2\",\n        resource: \"vpc\",\n        resourceName: this.vpcId,\n      },\n      AwsStack.ofAwsConstruct(this),\n    );\n    this.cidr = props.vpcCidrBlock;\n    this.availabilityZones = props.availabilityZones;\n    this._vpnGatewayId = props.vpnGatewayId;\n    this.incompleteSubnetDefinition = isIncomplete;\n\n    // None of the values may be unresolved list tokens\n    for (const k of Object.keys(props) as Array<keyof VpcAttributes>) {\n      if (Array.isArray(props[k]) && Token.isUnresolved(props[k])) {\n        // `@aws-cdk/aws-ec2:vpcAttributeIsListToken${k}`,\n        Annotations.of(this).addWarning(\n          `fromVpcAttributes: '${k}' is a list token: the imported VPC will not work with constructs that require a list of subnets at synthesis time. Use 'Vpc.fromLookup()' or 'Fn.importListValue' instead.`,\n        );\n      }\n    }\n\n    const pub = new ImportSubnetGroup(\n      props.publicSubnetIds,\n      props.publicSubnetNames,\n      props.publicSubnetRouteTableIds,\n      props.publicSubnetIpv4CidrBlocks,\n      SubnetType.PUBLIC,\n      this.availabilityZones,\n      \"publicSubnetIds\",\n      \"publicSubnetNames\",\n      \"publicSubnetRouteTableIds\",\n      \"publicSubnetIpv4CidrBlocks\",\n    );\n    const priv = new ImportSubnetGroup(\n      props.privateSubnetIds,\n      props.privateSubnetNames,\n      props.privateSubnetRouteTableIds,\n      props.privateSubnetIpv4CidrBlocks,\n      SubnetType.PRIVATE_WITH_EGRESS,\n      this.availabilityZones,\n      \"privateSubnetIds\",\n      \"privateSubnetNames\",\n      \"privateSubnetRouteTableIds\",\n      \"privateSubnetIpv4CidrBlocks\",\n    );\n    const iso = new ImportSubnetGroup(\n      props.isolatedSubnetIds,\n      props.isolatedSubnetNames,\n      props.isolatedSubnetRouteTableIds,\n      props.isolatedSubnetIpv4CidrBlocks,\n      SubnetType.PRIVATE_ISOLATED,\n      this.availabilityZones,\n      \"isolatedSubnetIds\",\n      \"isolatedSubnetNames\",\n      \"isolatedSubnetRouteTableIds\",\n      \"isolatedSubnetIpv4CidrBlocks\",\n    );\n\n    this.publicSubnets = pub.import(this);\n    this.privateSubnets = priv.import(this);\n    this.isolatedSubnets = iso.import(this);\n  }\n\n  public get vpcCidrBlock(): string {\n    if (this.cidr === undefined) {\n      throw new Error(\n        \"Cannot perform this operation: 'vpcCidrBlock' was not supplied when creating this VPC\",\n      );\n    }\n    return this.cidr;\n  }\n}\n\n// class LookedUpVpc extends VpcBase {\n//   public readonly vpcId: string;\n//   public readonly vpcArn: string;\n//   public readonly internetConnectivityEstablished: IDependable =\n//     new DependencyGroup();\n//   public readonly availabilityZones: string[];\n//   public readonly publicSubnets: ISubnet[];\n//   public readonly privateSubnets: ISubnet[];\n//   public readonly isolatedSubnets: ISubnet[];\n//   private readonly cidr?: string | undefined;\n\n//   constructor(\n//     scope: Construct,\n//     id: string,\n//     props: cxapi.VpcContextResponse,\n//     isIncomplete: boolean,\n//   ) {\n//     super(scope, id, {\n//       region: props.region,\n//       account: props.ownerAccountId,\n//     });\n\n//     this.vpcId = props.vpcId;\n//     this.vpcArn = Arn.format(\n//       {\n//         service: \"ec2\",\n//         resource: \"vpc\",\n//         resourceName: this.vpcId,\n//         region: this.env.region,\n//         account: this.env.account,\n//       },\n//       AwsStack.ofAwsConstruct(this),\n//     );\n//     this.cidr = props.vpcCidrBlock;\n//     this._vpnGatewayId = props.vpnGatewayId;\n//     this.incompleteSubnetDefinition = isIncomplete;\n\n//     const subnetGroups = props.subnetGroups || [];\n//     const availabilityZones = Array.from(\n//       new Set<string>(\n//         flatMap(subnetGroups, (subnetGroup) => {\n//           return subnetGroup.subnets.map((subnet) => subnet.availabilityZone);\n//         }),\n//       ),\n//     );\n//     availabilityZones.sort((az1, az2) => az1.localeCompare(az2));\n//     this.availabilityZones = availabilityZones;\n\n//     this.publicSubnets = this.extractSubnetsOfType(\n//       subnetGroups,\n//       cxapi.VpcSubnetGroupType.PUBLIC,\n//     );\n//     this.privateSubnets = this.extractSubnetsOfType(\n//       subnetGroups,\n//       cxapi.VpcSubnetGroupType.PRIVATE,\n//     );\n//     this.isolatedSubnets = this.extractSubnetsOfType(\n//       subnetGroups,\n//       cxapi.VpcSubnetGroupType.ISOLATED,\n//     );\n//   }\n\n//   public get vpcCidrBlock(): string {\n//     if (this.cidr === undefined) {\n//       // Value might be cached from an old CLI version, so bumping the CX API protocol to\n//       // force the value to exist would not have helped.\n//       throw new Error(\n//         \"Cannot perform this operation: 'vpcCidrBlock' was not found when looking up this VPC. Use a newer version of the CDK CLI and clear the old context value.\",\n//       );\n//     }\n//     return this.cidr;\n//   }\n\n//   private extractSubnetsOfType(\n//     subnetGroups: cxapi.VpcSubnetGroup[],\n//     subnetGroupType: cxapi.VpcSubnetGroupType,\n//   ): ISubnet[] {\n//     return flatMap(\n//       subnetGroups.filter(\n//         (subnetGroup) => subnetGroup.type === subnetGroupType,\n//       ),\n//       (subnetGroup) => this.subnetGroupToSubnets(subnetGroup),\n//     );\n//   }\n\n//   private subnetGroupToSubnets(subnetGroup: cxapi.VpcSubnetGroup): ISubnet[] {\n//     const ret = new Array<ISubnet>();\n//     for (let i = 0; i < subnetGroup.subnets.length; i++) {\n//       const vpcSubnet = subnetGroup.subnets[i];\n//       ret.push(\n//         Subnet.fromSubnetAttributes(this, `${subnetGroup.name}Subnet${i + 1}`, {\n//           availabilityZone: vpcSubnet.availabilityZone,\n//           subnetId: vpcSubnet.subnetId,\n//           routeTableId: vpcSubnet.routeTableId,\n//           ipv4CidrBlock: vpcSubnet.cidr,\n//         }),\n//       );\n//     }\n//     return ret;\n//   }\n// }\n\n// function flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[] {\n//   const ret = new Array<U>();\n//   for (const x of xs) {\n//     ret.push(...fn(x));\n//   }\n//   return ret;\n// }\n\nclass CompositeDependable implements IDependable {\n  private readonly dependables = new Array<IDependable>();\n\n  constructor() {\n    const self = this;\n    Dependable.implement(this, {\n      get dependencyRoots() {\n        const ret = new Array<IConstruct>();\n        for (const dep of self.dependables) {\n          ret.push(...Dependable.of(dep).dependencyRoots);\n        }\n        return ret;\n      },\n    });\n  }\n\n  /**\n   * Add a construct to the dependency roots\n   */\n  public add(dep: IDependable) {\n    this.dependables.push(dep);\n  }\n}\n\n/**\n * Invoke a function on a value (for its side effect) and return the value\n */\nfunction tap<T>(x: T, fn: (x: T) => void): T {\n  fn(x);\n  return x;\n}\n\nclass ImportedSubnet\n  extends AwsConstructBase\n  implements ISubnet, IPublicSubnet, IPrivateSubnet\n{\n  public readonly subnetOutputs: SubnetOutputs;\n  public get outputs(): Record<string, any> {\n    return this.subnetOutputs;\n  }\n  public readonly internetConnectivityEstablished: IDependable =\n    new DependencyGroup();\n  public readonly subnetId: string;\n  public readonly routeTable: IRouteTable;\n  private readonly _availabilityZone?: string;\n  private readonly _ipv4CidrBlock?: string;\n\n  constructor(scope: Construct, id: string, attrs: SubnetAttributes) {\n    super(scope, id, {\n      outputName: attrs.outputName,\n      registerOutputs: attrs.registerOutputs,\n    });\n\n    if (!attrs.routeTableId) {\n      // The following looks a little weird, but comes down to:\n      //\n      // * Is the subnetId itself unresolved ({ Ref: Subnet }); or\n      // * Was it the accidentally extracted first element of a list-encoded\n      //   token? ({ Fn::ImportValue: Subnets } => ['#{Token[1234]}'] =>\n      //   '#{Token[1234]}'\n      //\n      // There's no other API to test for the second case than to the string back into\n      // a list and see if the combination is Unresolved.\n      //\n      // In both cases we can't output the subnetId literally into the metadata (because it'll\n      // be useless). In the 2nd case even, if we output it to metadata, the `resolve()` call\n      // that gets done on the metadata will even `throw`, because the '#{Token}' value will\n      // occur in an illegal position (not in a list context).\n      const ref =\n        Token.isUnresolved(attrs.subnetId) ||\n        Token.isUnresolved([attrs.subnetId])\n          ? `at '${Node.of(scope).path}/${id}'`\n          : `'${attrs.subnetId}'`;\n      // eslint-disable-next-line max-len\n      // \"@aws-cdk/aws-ec2:noSubnetRouteTableId\",\n      Annotations.of(this).addWarning(\n        `No routeTableId was provided to the subnet ${ref}. Attempting to read its .routeTable.routeTableId will return null/undefined. (More info: https://github.com/aws/aws-cdk/pull/3171)`,\n      );\n    }\n    const lookup = new dataAwsSubnet.DataAwsSubnet(this, \"Resource\", {\n      id: attrs.subnetId,\n    });\n\n    this._ipv4CidrBlock = attrs.ipv4CidrBlock; // ?? lookup.cidrBlock;\n    this._availabilityZone = attrs.availabilityZone; // ?? lookup.availabilityZone;\n    this.subnetId = attrs.subnetId;\n    this.routeTable = {\n      // Forcing routeTableId to pretend non-null to maintain backwards-compatibility. See https://github.com/aws/aws-cdk/pull/3171\n      routeTableId: attrs.routeTableId!,\n    };\n    this.subnetOutputs = {\n      subnetId: this.subnetId,\n      routeTableId: this.routeTable.routeTableId,\n      ipv4CidrBlock: lookup.cidrBlock,\n    };\n  }\n\n  public get availabilityZone(): string {\n    if (!this._availabilityZone) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        \"You cannot reference a Subnet's availability zone if it was not supplied. Add the availabilityZone when importing using Subnet.fromSubnetAttributes()\",\n      );\n    }\n    return this._availabilityZone;\n  }\n\n  public get ipv4CidrBlock(): string {\n    if (!this._ipv4CidrBlock) {\n      // tslint:disable-next-line: max-line-length\n      throw new Error(\n        \"You cannot reference an imported Subnet's IPv4 CIDR if it was not supplied. Add the ipv4CidrBlock when importing using Subnet.fromSubnetAttributes()\",\n      );\n    }\n    return this._ipv4CidrBlock;\n  }\n\n  public associateNetworkAcl(id: string, networkAcl: INetworkAcl): void {\n    const scope = networkAcl instanceof Construct ? networkAcl : this;\n    const other = networkAcl instanceof Construct ? this : networkAcl;\n    new SubnetNetworkAclAssociation(scope, id + AwsStack.uniqueId(other.node), {\n      networkAcl,\n      subnet: this,\n    });\n  }\n}\n\n/**\n * Determine (and validate) the NAT gateway count w.r.t. the rest of the subnet configuration\n *\n * We have the following requirements:\n *\n * - NatGatewayCount = 0 ==> there are no private subnets\n * - NatGatewayCount > 0 ==> there must be public subnets\n *\n * Do we want to require that there are private subnets if there are NatGateways?\n * They seem pointless but I see no reason to prevent it.\n */\nfunction determineNatGatewayCount(\n  requestedCount: number | undefined,\n  subnetConfig: SubnetConfiguration[],\n  azCount: number,\n) {\n  const hasPrivateSubnets = subnetConfig.some(\n    (c) =>\n      (c.subnetType === SubnetType.PRIVATE_WITH_EGRESS ||\n        c.subnetType === SubnetType.PRIVATE ||\n        c.subnetType === SubnetType.PRIVATE_WITH_NAT) &&\n      !c.reserved,\n  );\n  const hasPublicSubnets = subnetConfig.some(\n    (c) => c.subnetType === SubnetType.PUBLIC && !c.reserved,\n  );\n  const hasCustomEgress = subnetConfig.some(\n    (c) => c.subnetType === SubnetType.PRIVATE_WITH_EGRESS,\n  );\n\n  const count =\n    requestedCount !== undefined\n      ? Math.min(requestedCount, azCount)\n      : hasPrivateSubnets\n        ? azCount\n        : 0;\n\n  if (count === 0 && hasPrivateSubnets && !hasCustomEgress) {\n    // eslint-disable-next-line max-len\n    throw new Error(\n      \"If you do not want NAT gateways (natGateways=0), make sure you don't configure any PRIVATE(_WITH_NAT) subnets in 'subnetConfiguration' (make them PUBLIC or ISOLATED instead)\",\n    );\n  }\n\n  if (count > 0 && !hasPublicSubnets) {\n    // eslint-disable-next-line max-len\n    throw new Error(\n      `If you configure PRIVATE subnets in 'subnetConfiguration', you must also configure PUBLIC subnets to put the NAT gateways into (got ${JSON.stringify(subnetConfig)}.`,\n    );\n  }\n\n  return count;\n}\n\n// /**\n//  * There are returned when the provider has not supplied props yet\n//  *\n//  * It's only used for testing and on the first run-through.\n//  */\n// const DUMMY_VPC_PROPS: cxapi.VpcContextResponse = {\n//   availabilityZones: [],\n//   vpcCidrBlock: \"1.2.3.4/5\",\n//   isolatedSubnetIds: undefined,\n//   isolatedSubnetNames: undefined,\n//   isolatedSubnetRouteTableIds: undefined,\n//   privateSubnetIds: undefined,\n//   privateSubnetNames: undefined,\n//   privateSubnetRouteTableIds: undefined,\n//   publicSubnetIds: undefined,\n//   publicSubnetNames: undefined,\n//   publicSubnetRouteTableIds: undefined,\n//   subnetGroups: [\n//     {\n//       name: \"Public\",\n//       type: cxapi.VpcSubnetGroupType.PUBLIC,\n//       subnets: [\n//         {\n//           availabilityZone: \"dummy1a\",\n//           subnetId: \"s-12345\",\n//           routeTableId: \"rtb-12345s\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//         {\n//           availabilityZone: \"dummy1b\",\n//           subnetId: \"s-67890\",\n//           routeTableId: \"rtb-67890s\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//       ],\n//     },\n//     {\n//       name: \"Private\",\n//       type: cxapi.VpcSubnetGroupType.PRIVATE,\n//       subnets: [\n//         {\n//           availabilityZone: \"dummy1a\",\n//           subnetId: \"p-12345\",\n//           routeTableId: \"rtb-12345p\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//         {\n//           availabilityZone: \"dummy1b\",\n//           subnetId: \"p-67890\",\n//           routeTableId: \"rtb-57890p\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//       ],\n//     },\n//     {\n//       name: \"Isolated\",\n//       type: cxapi.VpcSubnetGroupType.ISOLATED,\n//       subnets: [\n//         {\n//           availabilityZone: \"dummy1a\",\n//           subnetId: \"p-12345\",\n//           routeTableId: \"rtb-12345p\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//         {\n//           availabilityZone: \"dummy1b\",\n//           subnetId: \"p-67890\",\n//           routeTableId: \"rtb-57890p\",\n//           cidr: \"1.2.3.4/5\",\n//         },\n//       ],\n//     },\n//   ],\n//   vpcId: \"vpc-12345\",\n// };\n\n// moved due to cycles\n// ref: https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-ec2/lib/util.ts\n\n// /**\n//  * The default names for every subnet type\n//  */\n// export function defaultSubnetName(type: SubnetType) {\n//   switch (type) {\n//     case SubnetType.PUBLIC:\n//       return \"Public\";\n//     case SubnetType.PRIVATE_WITH_NAT:\n//     case SubnetType.PRIVATE_WITH_EGRESS:\n//     case SubnetType.PRIVATE:\n//       return \"Private\";\n//     case SubnetType.PRIVATE_ISOLATED:\n//     case SubnetType.ISOLATED:\n//       return \"Isolated\";\n//   }\n// }\n"]}