terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/vpc-v2-base.js

@@ -0,0 +1,493 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcV2Base = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/vpc-v2-base.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const subnet_1 = require("./subnet");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const client_vpn_endpoint_1 = require("./client-vpn-endpoint");
+const ec2_util_1 = require("./ec2-util");
+const route_1 = require("./route");
+const vpc_1 = require("./vpc");
+const vpc_endpoint_1 = require("./vpc-endpoint");
+const vpc_flow_logs_1 = require("./vpc-flow-logs");
+const vpn_1 = require("./vpn");
+const iam_1 = require("../iam");
+/**
+ * Base class for creating a VPC (Virtual Private Cloud) in AWS.
+ *
+ * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.
+ */
+class VpcV2Base extends aws_construct_1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * List of public subnets in this VPC
+         */
+        this.publicSubnets = [];
+        /**
+         * List of private subnets in this VPC
+         */
+        this.privateSubnets = [];
+        /**
+         * AZs for this VPC
+         */
+        this.availabilityZones = [];
+        /**
+         * Dependable that can be depended upon to force internet connectivity established on the VPC
+         * Add igw to this if its a public subnet
+         * @internal
+         */
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        /**
+         * If this is set to true, don't error out on trying to select subnets
+         */
+        this.incompleteSubnetDefinition = false;
+        /**
+         * Mutable private field for the internetGatewayId
+         * @internal
+         */
+        this._internetGatewayId = "";
+    }
+    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;
+    }
+    /**
+     * Return information on the subnets appropriate for the given selection strategy
+     *
+     * Requires that at least one subnet is matched, throws a descriptive
+     * error message otherwise.
+     */
+    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
+     * @deprecated use enableVpnGatewayV2 for compatibility with VPCV2.Route
+     */
+    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::EC2::VPNGatewayRoutePropagation 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 VPNGAtewayV2 to this VPC
+     */
+    enableVpnGatewayV2(options) {
+        if (this.vpnGatewayId) {
+            throw new Error("The VPN Gateway has already been enabled.");
+        }
+        const vpnGateway = new route_1.VPNGatewayV2(this, "VpnGateway", {
+            vpc: this,
+            ...options,
+        });
+        this._internetConnectivityEstablished.add(vpnGateway);
+        this._vpnGatewayId = vpnGateway.routerTargetId;
+        return vpnGateway;
+    }
+    /**
+     * 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 Egress Only Internet Gateway to this VPC and defines a new route
+     * to the route table of given subnets.
+     *
+     * @default - in case of no input subnets, no route is created
+     */
+    addEgressOnlyInternetGateway(options) {
+        const egw = new route_1.EgressOnlyInternetGateway(this, "EgressOnlyGW", {
+            vpc: this,
+            egressOnlyInternetGatewayName: options?.egressOnlyInternetGatewayName,
+        });
+        let useIpv6;
+        if (this.secondaryCidrBlock) {
+            useIpv6 = this.secondaryCidrBlock.some((secondaryAddress) => secondaryAddress.amazonProvidedIpv6CidrBlock === true ||
+                secondaryAddress.ipv6IpamPoolId != undefined);
+        }
+        if (!useIpv6) {
+            throw new Error("Egress only IGW can only be added to Ipv6 enabled VPC");
+        }
+        if (options?.subnets) {
+            const subnets = (0, ec2_util_1.flatten)(options.subnets.map((s) => this.selectSubnets(s).subnets));
+            subnets.forEach((subnet) => {
+                this.createEgressRoute(subnet, egw, options.destination);
+            });
+        }
+    }
+    /**
+     * Creates a route for EGW with destination set to outbound IPv6('::/0') or custom ipv6 address.
+     * @internal
+     */
+    createEgressRoute(subnet, egw, destination) {
+        const destinationIpv6 = destination ?? "::/0";
+        new route_1.Route(this, `${subnet.node.id}-EgressRoute`, {
+            routeTable: subnet.routeTable,
+            destination: destinationIpv6, // IPv6 default route
+            target: { gateway: egw },
+            routeName: "CDKEIGWRoute",
+        });
+    }
+    /**
+     * Adds a new Internet Gateway to this VPC
+     *
+     * @default - creates a new route for public subnets(with all outbound access) to the Internet Gateway.
+     */
+    addInternetGateway(options) {
+        if (this._internetGatewayId) {
+            throw new Error("The Internet Gateway has already been enabled.");
+        }
+        const igw = new route_1.InternetGateway(this, "InternetGateway", {
+            vpc: this,
+            internetGatewayName: options?.internetGatewayName,
+        });
+        this._internetConnectivityEstablished.add(igw);
+        this._internetGatewayId = igw.routerTargetId;
+        // If there are no public subnets defined, no default route will be added
+        if (this.publicSubnets) {
+            this.publicSubnets.forEach((s) => this.addDefaultInternetRoute(s, igw, options));
+        }
+    }
+    /**
+     * Adds default route for the internet gateway
+     * @internal
+     */
+    addDefaultInternetRoute(subnet, igw, options) {
+        if (subnet.subnetType !== vpc_1.SubnetType.PUBLIC) {
+            throw new Error("No public subnets defined to add route for internet gateway");
+        }
+        // Add default route to IGW for IPv6
+        if (subnet.ipv6CidrBlock) {
+            new route_1.Route(this, `${subnet.node.id}-DefaultIPv6Route`, {
+                routeTable: subnet.routeTable,
+                destination: options?.ipv6Destination ?? "::/0",
+                target: { gateway: igw },
+                routeName: "CDKDefaultIPv6Route",
+            });
+        }
+        //Add default route to IGW for IPv4
+        new route_1.Route(this, `${subnet.node.id}-DefaultRoute`, {
+            routeTable: subnet.routeTable,
+            destination: options?.ipv4Destination ?? "0.0.0.0/0",
+            target: { gateway: igw },
+            routeName: "CDKDefaultIPv4Route",
+        });
+    }
+    /**
+     * Adds a new NAT Gateway to the given subnet of this VPC
+     * of given subnets.
+     */
+    addNatGateway(options) {
+        if (options.connectivityType === route_1.NatConnectivityType.PUBLIC &&
+            !this._internetGatewayId) {
+            throw new Error("Cannot add a Public NAT Gateway without an Internet Gateway enabled on VPC");
+        }
+        return new route_1.NatGateway(this, "NATGateway", {
+            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,
+        });
+    }
+    /**
+     * Creates peering connection role for acceptor VPC
+     */
+    createAcceptorVpcRole(requestorAccountId) {
+        const peeringRole = new iam_1.Role(this, "VpcPeeringRole", {
+            assumedBy: new iam_1.AccountPrincipal(requestorAccountId),
+            roleName: "VpcPeeringRole",
+            description: "Restrictive role for VPC peering",
+        });
+        peeringRole.addToPolicy(new iam_1.PolicyStatement({
+            effect: iam_1.Effect.ALLOW,
+            actions: ["ec2:AcceptVpcPeeringConnection"],
+            resources: [
+                `arn:${aws_stack_1.AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc/${this.vpcId}`,
+            ],
+        }));
+        peeringRole.addToPolicy(new iam_1.PolicyStatement({
+            actions: ["ec2:AcceptVpcPeeringConnection"],
+            effect: iam_1.Effect.ALLOW,
+            resources: [
+                `arn:${aws_stack_1.AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc-peering-connection/*`,
+            ],
+            condition: [
+                {
+                    test: "StringEquals",
+                    variable: "ec2:AccepterVpc",
+                    values: [
+                        `arn:${aws_stack_1.AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc/${this.vpcId}`,
+                    ],
+                },
+            ],
+        }));
+        return peeringRole;
+    }
+    /**
+     * Creates a peering connection
+     */
+    createPeeringConnection(id, options) {
+        return new route_1.VPCPeeringConnection(this, id, {
+            requestorVpc: this,
+            ...options,
+        });
+    }
+    /**
+     * Returns the id of the VPN Gateway (if enabled)
+     */
+    get vpnGatewayId() {
+        return this._vpnGatewayId;
+    }
+    /**
+     * Returns the id of the Internet Gateway (if enabled)
+     */
+    get internetGatewayId() {
+        return this._internetGatewayId;
+    }
+    /**
+     * 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 || vpc_1.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 = {
+            [vpc_1.SubnetType.PRIVATE_ISOLATED]: this.isolatedSubnets,
+            [vpc_1.SubnetType.ISOLATED]: this.isolatedSubnets,
+            [vpc_1.SubnetType.PRIVATE_WITH_NAT]: this.privateSubnets,
+            [vpc_1.SubnetType.PRIVATE_WITH_EGRESS]: this.privateSubnets,
+            [vpc_1.SubnetType.PRIVATE]: this.privateSubnets,
+            [vpc_1.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) {
+        // TODO: throw error as new VpcV2 cannot support subnetName or subnetGroupName anymore
+        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
+                ? vpc_1.SubnetType.PRIVATE_WITH_EGRESS
+                : this.isolatedSubnets.length
+                    ? vpc_1.SubnetType.PRIVATE_ISOLATED
+                    : vpc_1.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;
+    }
+}
+exports.VpcV2Base = VpcV2Base;
+_a = JSII_RTTI_SYMBOL_1;
+VpcV2Base[_a] = { fqn: "terraconstructs.aws.compute.alpha.VpcV2Base", version: "0.0.12" };
+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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-v2-base.js","sourceRoot":"","sources":["../../../src/aws/compute/vpc-v2-base.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/vpc-v2-base.ts\n\nimport {\n  vpnGatewayAttachment,\n  vpnGatewayRoutePropagation,\n} from \"@cdktf/provider-aws\";\nimport { Annotations } from \"cdktf\";\nimport {\n  IDependable,\n  Dependable,\n  IConstruct,\n  DependencyGroup,\n} from \"constructs\";\nimport { SubnetFilter } from \"./subnet\";\nimport { AwsConstructBase } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport {\n  ClientVpnEndpointOptions,\n  ClientVpnEndpoint,\n} from \"./client-vpn-endpoint\";\nimport {\n  allRouteTableIds,\n  flatten,\n  subnetGroupNameFromConstructId,\n} from \"./ec2-util\";\nimport {\n  EgressOnlyInternetGateway,\n  InternetGateway,\n  NatConnectivityType,\n  NatGateway,\n  NatGatewayOptions,\n  Route,\n  VPCPeeringConnection,\n  VPCPeeringConnectionOptions,\n  VPNGatewayV2,\n} from \"./route\";\nimport { ISubnetV2 } from \"./subnet-v2\";\nimport {\n  VpcOutputs,\n  IVpc,\n  ISubnet,\n  SubnetSelection,\n  SelectedSubnets,\n  SubnetType,\n} from \"./vpc\";\nimport {\n  InterfaceVpcEndpointOptions,\n  InterfaceVpcEndpoint,\n  GatewayVpcEndpointOptions,\n  GatewayVpcEndpoint,\n} from \"./vpc-endpoint\";\nimport { FlowLogOptions, FlowLog, FlowLogResourceType } from \"./vpc-flow-logs\";\nimport {\n  EnableVpnGatewayOptions,\n  VpnConnection,\n  VpnConnectionOptions,\n  VpnConnectionType,\n  VpnGateway,\n} from \"./vpn\";\nimport { AccountPrincipal, Effect, PolicyStatement, Role } from \"../iam\";\nimport { IVPCCidrBlock } from \"./vpc-v2\";\n\n/**\n * Options to define EgressOnlyInternetGateway for VPC\n */\nexport interface EgressOnlyInternetGatewayOptions {\n  /**\n   * List of subnets where route to EGW will be added\n   *\n   * @default - no route created\n   */\n  readonly subnets?: SubnetSelection[];\n\n  /**\n   * Destination Ipv6 address for EGW route\n   *\n   * @default - '::/0' all Ipv6 traffic\n   */\n  readonly destination?: string;\n\n  /**\n   * The resource name of the egress-only internet gateway.\n   * Provided name will be used for tagging\n   *\n   * @default - no name tag associated and provisioned without a resource name\n   */\n  readonly egressOnlyInternetGatewayName?: string;\n}\n\n/**\n * Options to define InternetGateway for VPC\n */\nexport interface InternetGatewayOptions {\n  /**\n   * Destination Ipv6 address for EGW route\n   *\n   * @default - '0.0.0.0' all Ipv4 traffic\n   */\n  readonly ipv4Destination?: string;\n\n  /**\n   * Destination Ipv6 address for EGW route\n   *\n   * @default - '::/0' all Ipv6 traffic\n   */\n  readonly ipv6Destination?: string;\n\n  /**\n   * The resource name of the internet gateway.\n   * Provided name will be used for tagging\n   *\n   * @default - provisioned without a resource name\n   */\n  readonly internetGatewayName?: string;\n}\n\n/**\n * Options to define VPNGatewayV2 for VPC\n */\nexport interface VPNGatewayV2Options {\n  /**\n   * The type of VPN connection the virtual private gateway supports.\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html#cfn-ec2-vpngateway-type\n   */\n  readonly type: VpnConnectionType;\n\n  /**\n   * The private Autonomous System Number (ASN) for the Amazon side of a BGP session.\n   *\n   * @default - no ASN set for BGP session\n   */\n  readonly amazonSideAsn?: number;\n\n  /**\n   * The resource name of the VPN gateway.\n   *\n   * @default - resource provisioned without any name\n   */\n  readonly vpnGatewayName?: string;\n\n  /**\n   * Subnets where the route propagation should be added.\n   *\n   * @default - no propogation for routes\n   */\n  readonly vpnRoutePropagation?: SubnetSelection[];\n}\n\n/**\n * Placeholder to see what extra props we might need,\n * will be added to original IVPC\n */\nexport interface IVpcV2 extends IVpc {\n  /**\n   * The secondary CIDR blocks associated with the VPC.\n   *\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.\n   */\n  readonly secondaryCidrBlock?: IVPCCidrBlock[];\n\n  /**\n   * The primary IPv4 CIDR block associated with the VPC.\n   * Needed in order to validate the vpc range of subnet\n   * current prop vpcCidrBlock refers to the token value\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.\n   */\n  readonly ipv4CidrBlock: string;\n\n  /**\n   * Optional to override inferred region\n   *\n   * @default - current stack's environment region\n   */\n  readonly region: string;\n\n  /**\n   * The ID of the AWS account that owns the VPC\n   *\n   * @default - the account id of the parent stack\n   */\n  readonly ownerAccountId: string;\n\n  /**\n   * IPv4 CIDR provisioned under pool\n   * Required to check for overlapping CIDRs after provisioning\n   * is complete under IPAM pool\n   */\n  readonly ipv4IpamProvisionedCidrs?: string[];\n\n  /**\n   * VpcName to be used for tagging its components\n   * @attribute\n   */\n  readonly vpcName?: string;\n\n  /**\n   * Add an Egress only Internet Gateway to current VPC.\n   * Can only be used for ipv6 enabled VPCs.\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/egress-only-internet-gateway-basics.html}.\n   */\n  addEgressOnlyInternetGateway(\n    options?: EgressOnlyInternetGatewayOptions,\n  ): void;\n\n  /**\n   * Adds an Internet Gateway to current VPC.\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-igw-internet-access.html}.\n   *\n   * @default - defines route for all ipv4('0.0.0.0') and ipv6 addresses('::/0')\n   */\n  addInternetGateway(options?: InternetGatewayOptions): void;\n\n  /**\n   * Adds VPN Gateway to VPC and set route propogation.\n   * For more information, see the {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpngateway.html}.\n   *\n   * @default - no route propogation\n   */\n  enableVpnGatewayV2(options: VPNGatewayV2Options): VPNGatewayV2;\n\n  /**\n   * Adds a new NAT Gateway to VPC\n   * A NAT gateway is a Network Address Translation (NAT) service. NAT Gateway Connectivity can be of type `Public` or `Private`.\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html}.\n   *\n   * @default ConnectivityType.Public\n   */\n  addNatGateway(options: NatGatewayOptions): NatGateway;\n\n  /**\n   * Adds a new role to acceptor VPC account\n   * A cross account role is required for the VPC to peer with another account.\n   * For more information, see the {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/peer-with-vpc-in-another-account.html}.\n   */\n  createAcceptorVpcRole(requestorAccountId: string): Role;\n\n  /**\n   * Creates a new peering connection\n   * A peering connection is a private virtual network established between two VPCs.\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html}.\n   */\n  createPeeringConnection(\n    id: string,\n    options: VPCPeeringConnectionOptions,\n  ): VPCPeeringConnection;\n}\n\n/**\n * Base class for creating a VPC (Virtual Private Cloud) in AWS.\n *\n * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.\n */\nexport abstract class VpcV2Base extends AwsConstructBase implements IVpcV2 {\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 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 abstract readonly isolatedSubnets: ISubnet[];\n\n  /**\n   * AZs for this VPC\n   */\n  public readonly availabilityZones: string[] = [];\n\n  /**\n   * Dependable that can be depended upon to force internet connectivity established on the VPC\n   */\n  public abstract readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * Dependable that can be depended upon to force internet connectivity established on the VPC\n   * Add igw to this if its a public subnet\n   * @internal\n   */\n  protected readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  /**\n   * Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6\n   * Ipv4 should be within RFC#1918 range\n   */\n  public abstract readonly secondaryCidrBlock?: IVPCCidrBlock[];\n\n  /**\n   * The primary IPv4 CIDR block associated with the VPC.\n   * Needed in order to validate the vpc range of subnet\n   * current prop vpcCidrBlock refers to the token value\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.\n   */\n  public abstract readonly ipv4CidrBlock: string;\n\n  /**\n   * VpcName to be used for tagging its components\n   */\n  public abstract readonly vpcName?: string;\n\n  /**\n   * Region for this VPC\n   */\n  public abstract readonly region: string;\n\n  /**\n   * Identifier of the owner for this VPC\n   */\n  public abstract readonly ownerAccountId: string;\n\n  /**\n   * IPv4 CIDR provisioned under pool\n   * Required to check for overlapping CIDRs after provisioning\n   * is complete under IPAM pool\n   */\n  public abstract readonly ipv4IpamProvisionedCidrs?: string[];\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  /**\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   * @internal\n   */\n  protected _vpnGatewayId?: string;\n\n  /**\n   * Mutable private field for the internetGatewayId\n   * @internal\n   */\n  protected _internetGatewayId = \"\";\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  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   * @deprecated use enableVpnGatewayV2 for compatibility with VPCV2.Route\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::EC2::VPNGatewayRoutePropagation 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 VPNGAtewayV2 to this VPC\n   */\n  public enableVpnGatewayV2(options: VPNGatewayV2Options): VPNGatewayV2 {\n    if (this.vpnGatewayId) {\n      throw new Error(\"The VPN Gateway has already been enabled.\");\n    }\n\n    const vpnGateway = new VPNGatewayV2(this, \"VpnGateway\", {\n      vpc: this,\n      ...options,\n    });\n\n    this._internetConnectivityEstablished.add(vpnGateway);\n    this._vpnGatewayId = vpnGateway.routerTargetId;\n\n    return vpnGateway;\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 Egress Only Internet Gateway to this VPC and defines a new route\n   * to the route table of given subnets.\n   *\n   * @default - in case of no input subnets, no route is created\n   */\n  public addEgressOnlyInternetGateway(\n    options?: EgressOnlyInternetGatewayOptions,\n  ): void {\n    const egw = new EgressOnlyInternetGateway(this, \"EgressOnlyGW\", {\n      vpc: this,\n      egressOnlyInternetGatewayName: options?.egressOnlyInternetGatewayName,\n    });\n\n    let useIpv6;\n    if (this.secondaryCidrBlock) {\n      useIpv6 = this.secondaryCidrBlock.some(\n        (secondaryAddress) =>\n          secondaryAddress.amazonProvidedIpv6CidrBlock === true ||\n          secondaryAddress.ipv6IpamPoolId != undefined,\n      );\n    }\n\n    if (!useIpv6) {\n      throw new Error(\"Egress only IGW can only be added to Ipv6 enabled VPC\");\n    }\n\n    if (options?.subnets) {\n      const subnets = flatten(\n        options.subnets.map((s) => this.selectSubnets(s).subnets),\n      );\n      subnets.forEach((subnet) => {\n        this.createEgressRoute(subnet, egw, options.destination);\n      });\n    }\n  }\n\n  /**\n   * Creates a route for EGW with destination set to outbound IPv6('::/0') or custom ipv6 address.\n   * @internal\n   */\n  private createEgressRoute(\n    subnet: ISubnetV2,\n    egw: EgressOnlyInternetGateway,\n    destination?: string,\n  ): void {\n    const destinationIpv6 = destination ?? \"::/0\";\n    new Route(this, `${subnet.node.id}-EgressRoute`, {\n      routeTable: subnet.routeTable,\n      destination: destinationIpv6, // IPv6 default route\n      target: { gateway: egw },\n      routeName: \"CDKEIGWRoute\",\n    });\n  }\n\n  /**\n   * Adds a new Internet Gateway to this VPC\n   *\n   * @default - creates a new route for public subnets(with all outbound access) to the Internet Gateway.\n   */\n  public addInternetGateway(options?: InternetGatewayOptions): void {\n    if (this._internetGatewayId) {\n      throw new Error(\"The Internet Gateway has already been enabled.\");\n    }\n\n    const igw = new InternetGateway(this, \"InternetGateway\", {\n      vpc: this,\n      internetGatewayName: options?.internetGatewayName,\n    });\n\n    this._internetConnectivityEstablished.add(igw);\n    this._internetGatewayId = igw.routerTargetId;\n\n    // If there are no public subnets defined, no default route will be added\n    if (this.publicSubnets) {\n      this.publicSubnets.forEach((s) =>\n        this.addDefaultInternetRoute(s, igw, options),\n      );\n    }\n  }\n\n  /**\n   * Adds default route for the internet gateway\n   * @internal\n   */\n  private addDefaultInternetRoute(\n    subnet: ISubnetV2,\n    igw: InternetGateway,\n    options?: InternetGatewayOptions,\n  ): void {\n    if (subnet.subnetType !== SubnetType.PUBLIC) {\n      throw new Error(\n        \"No public subnets defined to add route for internet gateway\",\n      );\n    }\n\n    // Add default route to IGW for IPv6\n    if (subnet.ipv6CidrBlock) {\n      new Route(this, `${subnet.node.id}-DefaultIPv6Route`, {\n        routeTable: subnet.routeTable,\n        destination: options?.ipv6Destination ?? \"::/0\",\n        target: { gateway: igw },\n        routeName: \"CDKDefaultIPv6Route\",\n      });\n    }\n    //Add default route to IGW for IPv4\n    new Route(this, `${subnet.node.id}-DefaultRoute`, {\n      routeTable: subnet.routeTable,\n      destination: options?.ipv4Destination ?? \"0.0.0.0/0\",\n      target: { gateway: igw },\n      routeName: \"CDKDefaultIPv4Route\",\n    });\n  }\n\n  /**\n   * Adds a new NAT Gateway to the given subnet of this VPC\n   * of given subnets.\n   */\n  public addNatGateway(options: NatGatewayOptions): NatGateway {\n    if (\n      options.connectivityType === NatConnectivityType.PUBLIC &&\n      !this._internetGatewayId\n    ) {\n      throw new Error(\n        \"Cannot add a Public NAT Gateway without an Internet Gateway enabled on VPC\",\n      );\n    }\n    return new NatGateway(this, \"NATGateway\", {\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   * Creates peering connection role for acceptor VPC\n   */\n  public createAcceptorVpcRole(requestorAccountId: string): Role {\n    const peeringRole = new Role(this, \"VpcPeeringRole\", {\n      assumedBy: new AccountPrincipal(requestorAccountId),\n      roleName: \"VpcPeeringRole\",\n      description: \"Restrictive role for VPC peering\",\n    });\n\n    peeringRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\"ec2:AcceptVpcPeeringConnection\"],\n        resources: [\n          `arn:${AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc/${this.vpcId}`,\n        ],\n      }),\n    );\n\n    peeringRole.addToPolicy(\n      new PolicyStatement({\n        actions: [\"ec2:AcceptVpcPeeringConnection\"],\n        effect: Effect.ALLOW,\n        resources: [\n          `arn:${AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc-peering-connection/*`,\n        ],\n        condition: [\n          {\n            test: \"StringEquals\",\n            variable: \"ec2:AccepterVpc\",\n            values: [\n              `arn:${AwsStack.ofAwsConstruct(this).partition}:ec2:${this.region}:${this.ownerAccountId}:vpc/${this.vpcId}`,\n            ],\n          },\n        ],\n      }),\n    );\n\n    return peeringRole;\n  }\n\n  /**\n   * Creates a peering connection\n   */\n  public createPeeringConnection(\n    id: string,\n    options: VPCPeeringConnectionOptions,\n  ): VPCPeeringConnection {\n    return new VPCPeeringConnection(this, id, {\n      requestorVpc: 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   * Returns the id of the Internet Gateway (if enabled)\n   */\n  public get internetGatewayId(): string | undefined {\n    return this._internetGatewayId;\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    // TODO: throw error as new VpcV2 cannot support subnetName or subnetGroupName anymore\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\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"]}