@aws-cdk/aws-ec2-alpha 2.156.0-alpha.0

package/lib/subnet-v2.js

@@ -0,0 +1,272 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubnetV2 = exports.IpCidr = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const constructs_1 = require("constructs");
+const util_1 = require("./util");
+/**
+ * IPv4 or IPv6 CIDR range for the subnet
+ */
+class IpCidr {
+    constructor(props) {
+        this.cidr = props;
+    }
+}
+exports.IpCidr = IpCidr;
+_a = JSII_RTTI_SYMBOL_1;
+IpCidr[_a] = { fqn: "@aws-cdk/aws-ec2-alpha.IpCidr", version: "2.156.0-alpha.0" };
+/**
+ * The SubnetV2 class represents a subnet within a VPC (Virtual Private Cloud) in AWS.
+ * It extends the Resource class and implements the ISubnet interface.
+ *
+ * Instances of this class can be used to create and manage subnets within a VpcV2 instance.
+ * Subnets can be configured with specific IP address ranges (IPv4 and IPv6), availability zones,
+ * and subnet types (e.g., public, private, isolated).
+ *
+ * @resource AWS::EC2::Subnet
+ *
+ */
+class SubnetV2 extends aws_cdk_lib_1.Resource {
+    /**
+     * Constructs a new SubnetV2 instance.
+     * @param scope The parent Construct that this resource will be part of.
+     * @param id The unique identifier for this resource.
+     * @param props The configuration properties for the subnet.
+     */
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.subnetName ?? aws_cdk_lib_1.Lazy.string({
+                produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 128, allowedSpecialCharacters: '_' }),
+            }),
+        });
+        /**
+         * The variable name `internetConnectivityEstablished` does not reflect what it actually is.
+         * The naming is enforced by ISubnet. We need to keep it to maintain compatibility.
+         * It exposes the RouteTable-Subnet association so that other resources can depend on it.
+         * E.g. Resources in a subnet, when being deleted, may need the RouteTable to exist in order to delete properly
+         */
+        this._internetConnectivityEstablished = new constructs_1.DependencyGroup();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_ec2_alpha_SubnetV2Props(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, SubnetV2);
+            }
+            throw error;
+        }
+        const ipv4CidrBlock = props.ipv4CidrBlock.cidr;
+        const ipv6CidrBlock = props.ipv6CidrBlock?.cidr;
+        if (!checkCidrRanges(props.vpc, props.ipv4CidrBlock.cidr)) {
+            throw new Error('CIDR block should be within the range of VPC');
+        }
+        ;
+        let overlap = false;
+        let overlapIpv6 = false;
+        overlap = validateOverlappingCidrRanges(props.vpc, props.ipv4CidrBlock.cidr);
+        //check whether VPC supports ipv6
+        if (props.ipv6CidrBlock?.cidr) {
+            validateSupportIpv6(props.vpc);
+            overlapIpv6 = validateOverlappingCidrRangesipv6(props.vpc, props.ipv6CidrBlock?.cidr);
+        }
+        if (overlap || overlapIpv6) {
+            throw new Error('CIDR block should not overlap with existing subnet blocks');
+        }
+        if (props.assignIpv6AddressOnCreation && !props.ipv6CidrBlock) {
+            throw new Error('IPv6 CIDR block is required when assigning IPv6 address on creation');
+        }
+        const subnet = new aws_ec2_1.CfnSubnet(this, 'Subnet', {
+            vpcId: props.vpc.vpcId,
+            cidrBlock: ipv4CidrBlock,
+            ipv6CidrBlock: ipv6CidrBlock,
+            availabilityZone: props.availabilityZone,
+            assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation ?? false,
+        });
+        this.node.defaultChild = subnet;
+        this.ipv4CidrBlock = props.ipv4CidrBlock.cidr;
+        this.ipv6CidrBlock = props.ipv6CidrBlock?.cidr;
+        this.subnetId = subnet.ref;
+        this.availabilityZone = props.availabilityZone;
+        this._networkAcl = aws_ec2_1.NetworkAcl.fromNetworkAclId(this, 'Acl', subnet.attrNetworkAclAssociationId);
+        if (props.routeTable) {
+            this.routeTable = props.routeTable;
+        }
+        else {
+            const defaultTable = new aws_ec2_1.CfnRouteTable(this, 'RouteTable', {
+                vpcId: props.vpc.vpcId,
+            });
+            this.routeTable = { routeTableId: defaultTable.ref };
+        }
+        const routeAssoc = new aws_ec2_1.CfnSubnetRouteTableAssociation(this, 'RouteTableAssociation', {
+            subnetId: this.subnetId,
+            routeTableId: this.routeTable.routeTableId,
+        });
+        this._internetConnectivityEstablished.add(routeAssoc);
+        this.internetConnectivityEstablished = this._internetConnectivityEstablished;
+        this.subnetType = props.subnetType;
+        storeSubnetToVpcByType(props.vpc, this, props.subnetType);
+    }
+    /**
+     * Associate a Network ACL with this subnet
+     *
+     * @param id The unique identifier for this association.
+     * @param networkAcl The Network ACL to associate with this subnet.
+     * This allows controlling inbound and outbound traffic for instances in this subnet.
+     */
+    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 aws_ec2_1.SubnetNetworkAclAssociation(scope, id + aws_cdk_lib_1.Names.nodeUniqueId(other.node), {
+            networkAcl,
+            subnet: this,
+        });
+    }
+    /**
+     * Returns the Network ACL associated with this subnet.
+     */
+    get networkAcl() {
+        return this._networkAcl;
+    }
+}
+exports.SubnetV2 = SubnetV2;
+_b = JSII_RTTI_SYMBOL_1;
+SubnetV2[_b] = { fqn: "@aws-cdk/aws-ec2-alpha.SubnetV2", version: "2.156.0-alpha.0" };
+const subnetTypeMap = {
+    [aws_ec2_1.SubnetType.PRIVATE_ISOLATED]: (vpc, subnet) => vpc.isolatedSubnets.push(subnet),
+    [aws_ec2_1.SubnetType.PUBLIC]: (vpc, subnet) => vpc.publicSubnets.push(subnet),
+    [aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+    [aws_ec2_1.SubnetType.ISOLATED]: (vpc, subnet) => vpc.isolatedSubnets.push(subnet),
+    [aws_ec2_1.SubnetType.PRIVATE]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+    [aws_ec2_1.SubnetType.PRIVATE_WITH_NAT]: (vpc, subnet) => vpc.privateSubnets.push(subnet),
+};
+/**
+ * Stores the provided subnet in the VPC's collection of subnets based on the specified subnet type.
+ *
+ * @param vpc The VPC instance to which the subnet belongs.
+ * @param subnet The subnet instance to be stored.
+ * @param type The type of the subnet (e.g., public, private, isolated).
+ * @internal
+ */
+function storeSubnetToVpcByType(vpc, subnet, type) {
+    const findFunctionType = subnetTypeMap[type];
+    if (findFunctionType) {
+        findFunctionType(vpc, subnet);
+    }
+    else {
+        throw new Error(`Unsupported subnet type: ${type}`);
+    }
+    /**
+     * Need to set explicit dependency as during stack deletion,
+     * the cidr blocks may get deleted first and will fail as the subnets are still using the cidr blocks
+     */
+    for (const cidr of vpc.secondaryCidrBlock) {
+        subnet.node.addDependency(cidr);
+    }
+}
+/**
+ * Validates whether the provided VPC supports IPv6 addresses.
+ *
+ * @param vpc The VPC instance to be validated.
+ * @throws Error if the VPC does not support IPv6 addresses.
+ * @returns True if the VPC supports IPv6 addresses, false otherwise.
+ * @internal
+ */
+function validateSupportIpv6(vpc) {
+    if (vpc.secondaryCidrBlock.some((secondaryAddress) => secondaryAddress.amazonProvidedIpv6CidrBlock === true ||
+        secondaryAddress.ipv6IpamPoolId != undefined)) {
+        return true;
+    }
+    else {
+        throw new Error('To use IPv6, the VPC must enable IPv6 support.');
+    }
+}
+/**
+ * Checks if the provided CIDR range falls within the IP address ranges of the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param cidrRange The CIDR range to be checked.
+ * @returns True if the CIDR range falls within the VPC's IP address ranges, false otherwise.
+ * @internal
+ */
+function checkCidrRanges(vpc, cidrRange) {
+    const vpcCidrBlock = [vpc.ipv4CidrBlock];
+    for (const ipAddress of vpc.secondaryCidrBlock) {
+        if (ipAddress.cidrBlock) {
+            vpcCidrBlock.push(ipAddress.cidrBlock);
+        }
+    }
+    const cidrs = vpcCidrBlock.map(cidr => new util_1.CidrBlock(cidr));
+    const subnetCidrBlock = new util_1.CidrBlock(cidrRange);
+    return cidrs.some(c => c.containsCidr(subnetCidrBlock));
+}
+/**
+ * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param ipv4CidrBlock The IPv4 CIDR block to be validated.
+ * @returns True if the IPv4 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.
+ * @internal
+ */
+function validateOverlappingCidrRanges(vpc, ipv4CidrBlock) {
+    let allSubnets;
+    try {
+        allSubnets = vpc.selectSubnets().subnets;
+    }
+    catch (e) {
+        'No subnets in VPC';
+        return false;
+    }
+    const ipMap = new Array();
+    const inputRange = new util_1.CidrBlock(ipv4CidrBlock);
+    const inputIpMap = [inputRange.minIp(), inputRange.maxIp()];
+    for (const subnet of allSubnets) {
+        const cidrBlock = new util_1.CidrBlock(subnet.ipv4CidrBlock);
+        ipMap.push([cidrBlock.minIp(), cidrBlock.maxIp()]);
+    }
+    for (const range of ipMap) {
+        if (inputRange.rangesOverlap(range, inputIpMap)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Validates if the provided IPv6 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.
+ *
+ * @param vpc The VPC instance to check against.
+ * @param ipv6CidrBlock The IPv6 CIDR block to be validated.
+ * @returns True if the IPv6 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.
+ * @throws Error if no subnets are found in the VPC.
+ * @internal
+ */
+function validateOverlappingCidrRangesipv6(vpc, ipv6CidrBlock) {
+    let allSubnets;
+    try {
+        allSubnets = vpc.selectSubnets().subnets;
+    }
+    catch (e) {
+        'No subnets in VPC';
+        return false;
+    }
+    const ipv6Map = [];
+    const inputRange = new util_1.CidrBlockIpv6(ipv6CidrBlock);
+    let result = false;
+    for (const subnet of allSubnets) {
+        if (subnet.ipv6CidrBlock) {
+            const cidrBlock = new util_1.CidrBlockIpv6(subnet.ipv6CidrBlock);
+            ipv6Map.push(cidrBlock.cidr);
+        }
+    }
+    for (const range of ipv6Map) {
+        if (inputRange.rangesOverlap(range, inputRange.cidr)) {
+            result = true;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subnet-v2.js","sourceRoot":"","sources":["subnet-v2.ts"],"names":[],"mappings":"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","sourcesContent":["import { Resource, Names, Lazy } from 'aws-cdk-lib';\nimport { CfnRouteTable, CfnSubnet, CfnSubnetRouteTableAssociation, INetworkAcl, IRouteTable, ISubnet, NetworkAcl, SubnetNetworkAclAssociation, SubnetType } from 'aws-cdk-lib/aws-ec2';\nimport { Construct, DependencyGroup, IDependable } from 'constructs';\nimport { IVpcV2 } from './vpc-v2-base';\nimport { CidrBlock, CidrBlockIpv6 } from './util';\n\n/**\n * Interface to define subnet CIDR\n */\ninterface ICidr {\n  readonly cidr: string;\n}\n\n/**\n * IPv4 or IPv6 CIDR range for the subnet\n */\nexport class IpCidr implements ICidr {\n\n  /**\n * IPv6 CIDR range for the subnet\n * Allowed only if IPv6 is enabled on VPc\n */\n  public readonly cidr: string;\n  constructor(props: string ) {\n    this.cidr = props;\n  }\n}\n\n/**\n * Properties to define subnet for VPC.\n */\nexport interface SubnetV2Props {\n/**\n * VPC Prop\n */\n  readonly vpc: IVpcV2;\n\n  /**\n   * ipv4 cidr to assign to this subnet.\n   * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html#cfn-ec2-subnet-cidrblock\n   */\n  readonly ipv4CidrBlock: IpCidr;\n\n  /**\n   * Ipv6 CIDR Range for subnet\n   * @default No Ipv6 address\n   */\n  readonly ipv6CidrBlock?: IpCidr;\n\n  /**\n   * Custom AZ for the subnet\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * Custom Route for subnet\n   * @default Default route table\n   */\n  readonly routeTable?: IRouteTable;\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   * TODO: Add validation check `subnetType` when adding resources (e.g. cannot add NatGateway to private)\n   */\n  readonly subnetType: SubnetType;\n\n  /**\n   * Subnet name\n   * @default none\n   */\n  readonly subnetName?: 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/**\n * Interface with additional properties for SubnetV2\n */\nexport interface ISubnetV2 extends ISubnet {\n\n  /**\n   * The IPv6 CIDR block for this subnet\n   */\n  readonly ipv6CidrBlock?: string;\n\n}\n\n/**\n * The SubnetV2 class represents a subnet within a VPC (Virtual Private Cloud) in AWS.\n * It extends the Resource class and implements the ISubnet interface.\n *\n * Instances of this class can be used to create and manage subnets within a VpcV2 instance.\n * Subnets can be configured with specific IP address ranges (IPv4 and IPv6), availability zones,\n * and subnet types (e.g., public, private, isolated).\n *\n * @resource AWS::EC2::Subnet\n *\n */\nexport class SubnetV2 extends Resource implements ISubnetV2 {\n\n  /**\n   * The Availability Zone the subnet is located in\n   */\n  public readonly availabilityZone: string;\n\n  /**\n   * The subnetId for this particular subnet\n   * @attribute\n   */\n  public readonly subnetId: string;\n\n  /**\n   *  Dependencies for internet connectivity\n   * This Property exposes the RouteTable-Subnet association so that other resources can depend on it.\n   */\n  public readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * The variable name `internetConnectivityEstablished` does not reflect what it actually is.\n   * The naming is enforced by ISubnet. We need to keep it to maintain compatibility.\n   * It exposes the RouteTable-Subnet association so that other resources can depend on it.\n   * E.g. Resources in a subnet, when being deleted, may need the RouteTable to exist in order to delete properly\n   */\n  private readonly _internetConnectivityEstablished = new DependencyGroup();\n\n  /**\n   * The IPv4 CIDR block for this subnet\n   */\n  public readonly ipv4CidrBlock: string;\n\n  /**\n   * The IPv6 CIDR Block for this subnet\n   */\n  public readonly ipv6CidrBlock?: string;\n\n  /**\n   * The route table for this subnet\n   */\n  public readonly routeTable: IRouteTable;\n\n  /**\n   * The type of subnet (public or private) that this subnet represents.\n   * @attribute SubnetType\n   */\n  public readonly subnetType: SubnetType;\n\n  private _networkAcl: INetworkAcl;\n\n  /**\n   * Constructs a new SubnetV2 instance.\n   * @param scope The parent Construct that this resource will be part of.\n   * @param id The unique identifier for this resource.\n   * @param props The configuration properties for the subnet.\n   */\n  constructor(scope: Construct, id: string, props: SubnetV2Props) {\n    super(scope, id, {\n      physicalName: props.subnetName ?? Lazy.string({\n        produce: () => Names.uniqueResourceName(this, { maxLength: 128, allowedSpecialCharacters: '_' }),\n      }),\n    });\n\n    const ipv4CidrBlock = props.ipv4CidrBlock.cidr;\n    const ipv6CidrBlock = props.ipv6CidrBlock?.cidr;\n\n    if (!checkCidrRanges(props.vpc, props.ipv4CidrBlock.cidr)) {\n      throw new Error('CIDR block should be within the range of VPC');\n    };\n\n    let overlap: boolean = false;\n    let overlapIpv6: boolean = false;\n\n    overlap = validateOverlappingCidrRanges(props.vpc, props.ipv4CidrBlock.cidr);\n\n    //check whether VPC supports ipv6\n    if (props.ipv6CidrBlock?.cidr) {\n      validateSupportIpv6(props.vpc);\n      overlapIpv6 = validateOverlappingCidrRangesipv6(props.vpc, props.ipv6CidrBlock?.cidr);\n    }\n\n    if (overlap || overlapIpv6) {\n      throw new Error('CIDR block should not overlap with existing subnet blocks');\n    }\n\n    if (props.assignIpv6AddressOnCreation && !props.ipv6CidrBlock) {\n      throw new Error('IPv6 CIDR block is required when assigning IPv6 address on creation');\n    }\n\n    const subnet = new CfnSubnet(this, 'Subnet', {\n      vpcId: props.vpc.vpcId,\n      cidrBlock: ipv4CidrBlock,\n      ipv6CidrBlock: ipv6CidrBlock,\n      availabilityZone: props.availabilityZone,\n      assignIpv6AddressOnCreation: props.assignIpv6AddressOnCreation ?? false,\n    });\n\n    this.node.defaultChild = subnet;\n    this.ipv4CidrBlock = props.ipv4CidrBlock.cidr;\n    this.ipv6CidrBlock = props.ipv6CidrBlock?.cidr;\n    this.subnetId = subnet.ref;\n    this.availabilityZone = props.availabilityZone;\n\n    this._networkAcl = NetworkAcl.fromNetworkAclId(this, 'Acl', subnet.attrNetworkAclAssociationId);\n\n    if (props.routeTable) {\n      this.routeTable = props.routeTable;\n    } else {\n      const defaultTable = new CfnRouteTable(this, 'RouteTable', {\n        vpcId: props.vpc.vpcId,\n      });\n      this.routeTable = { routeTableId: defaultTable.ref };\n    }\n\n    const routeAssoc = new CfnSubnetRouteTableAssociation(this, 'RouteTableAssociation', {\n      subnetId: this.subnetId,\n      routeTableId: this.routeTable.routeTableId,\n    });\n    this._internetConnectivityEstablished.add(routeAssoc);\n    this.internetConnectivityEstablished = this._internetConnectivityEstablished;\n\n    this.subnetType = props.subnetType;\n    storeSubnetToVpcByType(props.vpc, this, props.subnetType);\n  }\n\n  /**\n   * Associate a Network ACL with this subnet\n   *\n   * @param id The unique identifier for this association.\n   * @param networkAcl The Network ACL to associate with this subnet.\n   * This allows controlling inbound and outbound traffic for instances in this subnet.\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 + Names.nodeUniqueId(other.node), {\n      networkAcl,\n      subnet: this,\n    });\n  }\n  /**\n   * Returns the Network ACL associated with this subnet.\n   */\n\n  public get networkAcl(): INetworkAcl {\n    return this._networkAcl;\n  }\n}\n\nconst subnetTypeMap = {\n  [SubnetType.PRIVATE_ISOLATED]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.isolatedSubnets.push(subnet),\n  [SubnetType.PUBLIC]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.publicSubnets.push(subnet),\n  [SubnetType.PRIVATE_WITH_EGRESS]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.privateSubnets.push(subnet),\n  [SubnetType.ISOLATED]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.isolatedSubnets.push(subnet),\n  [SubnetType.PRIVATE]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.privateSubnets.push(subnet),\n  [SubnetType.PRIVATE_WITH_NAT]: (vpc: IVpcV2, subnet: SubnetV2) => vpc.privateSubnets.push(subnet),\n};\n\n/**\n * Stores the provided subnet in the VPC's collection of subnets based on the specified subnet type.\n *\n * @param vpc The VPC instance to which the subnet belongs.\n * @param subnet The subnet instance to be stored.\n * @param type The type of the subnet (e.g., public, private, isolated).\n * @internal\n */\nfunction storeSubnetToVpcByType(vpc: IVpcV2, subnet: SubnetV2, type: SubnetType) {\n  const findFunctionType = subnetTypeMap[type];\n  if (findFunctionType) {\n    findFunctionType(vpc, subnet);\n  } else {\n    throw new Error(`Unsupported subnet type: ${type}`);\n  }\n\n  /**\n   * Need to set explicit dependency as during stack deletion,\n   * the cidr blocks may get deleted first and will fail as the subnets are still using the cidr blocks\n   */\n  for (const cidr of vpc.secondaryCidrBlock) {\n    subnet.node.addDependency(cidr);\n  }\n}\n\n/**\n * Validates whether the provided VPC supports IPv6 addresses.\n *\n * @param vpc The VPC instance to be validated.\n * @throws Error if the VPC does not support IPv6 addresses.\n * @returns True if the VPC supports IPv6 addresses, false otherwise.\n * @internal\n */\nfunction validateSupportIpv6(vpc: IVpcV2) {\n  if (vpc.secondaryCidrBlock.some((secondaryAddress) => secondaryAddress.amazonProvidedIpv6CidrBlock === true ||\n  secondaryAddress.ipv6IpamPoolId != undefined)) {\n    return true;\n  } else {\n    throw new Error('To use IPv6, the VPC must enable IPv6 support.');\n  }\n}\n\n/**\n * Checks if the provided CIDR range falls within the IP address ranges of the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param cidrRange The CIDR range to be checked.\n * @returns True if the CIDR range falls within the VPC's IP address ranges, false otherwise.\n * @internal\n */\nfunction checkCidrRanges(vpc: IVpcV2, cidrRange: string) {\n\n  const vpcCidrBlock = [vpc.ipv4CidrBlock];\n\n  for (const ipAddress of vpc.secondaryCidrBlock) {\n    if (ipAddress.cidrBlock) {\n      vpcCidrBlock.push(ipAddress.cidrBlock);\n    }\n  }\n  const cidrs = vpcCidrBlock.map(cidr => new CidrBlock(cidr));\n\n  const subnetCidrBlock = new CidrBlock(cidrRange);\n\n  return cidrs.some(c => c.containsCidr(subnetCidrBlock));\n\n}\n\n/**\n * Validates if the provided IPv4 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param ipv4CidrBlock The IPv4 CIDR block to be validated.\n * @returns True if the IPv4 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.\n * @internal\n */\n\nfunction validateOverlappingCidrRanges(vpc: IVpcV2, ipv4CidrBlock: string): boolean {\n\n  let allSubnets: ISubnetV2[];\n  try {\n    allSubnets = vpc.selectSubnets().subnets;\n  } catch (e) {\n    'No subnets in VPC';\n    return false;\n  }\n\n  const ipMap: [string, string][] = new Array();\n\n  const inputRange = new CidrBlock(ipv4CidrBlock);\n\n  const inputIpMap: [string, string] = [inputRange.minIp(), inputRange.maxIp()];\n\n  for (const subnet of allSubnets) {\n    const cidrBlock = new CidrBlock(subnet.ipv4CidrBlock);\n    ipMap.push([cidrBlock.minIp(), cidrBlock.maxIp()]);\n  }\n\n  for (const range of ipMap) {\n    if (inputRange.rangesOverlap(range, inputIpMap)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Validates if the provided IPv6 CIDR block overlaps with existing subnet CIDR blocks within the given VPC.\n *\n * @param vpc The VPC instance to check against.\n * @param ipv6CidrBlock The IPv6 CIDR block to be validated.\n * @returns True if the IPv6 CIDR block overlaps with existing subnet CIDR blocks, false otherwise.\n * @throws Error if no subnets are found in the VPC.\n * @internal\n */\nfunction validateOverlappingCidrRangesipv6(vpc: IVpcV2, ipv6CidrBlock: string): boolean {\n\n  let allSubnets: ISubnetV2[];\n  try {\n    allSubnets = vpc.selectSubnets().subnets;\n  } catch (e) {\n    'No subnets in VPC';\n    return false;\n  }\n\n  const ipv6Map: string[]= [];\n\n  const inputRange = new CidrBlockIpv6(ipv6CidrBlock);\n\n  let result : boolean = false;\n\n  for (const subnet of allSubnets) {\n    if (subnet.ipv6CidrBlock) {\n      const cidrBlock = new CidrBlockIpv6(subnet.ipv6CidrBlock);\n      ipv6Map.push(cidrBlock.cidr);\n    }\n  }\n\n  for (const range of ipv6Map) {\n    if (inputRange.rangesOverlap(range, inputRange.cidr)) {\n      result = true;\n    }\n  }\n\n  return result;\n}\n"]}

package/lib/util.d.ts

@@ -0,0 +1,157 @@
+import { ISubnet } from 'aws-cdk-lib/aws-ec2';
+/**
+ * Return a subnet name from its construct ID
+ *
+ * All subnet names look like NAME <> "Subnet" <> INDEX
+ */
+export declare function subnetGroupNameFromConstructId(subnet: ISubnet): string;
+/**
+ * Make the subnet construct ID from a name and number
+ */
+export declare function subnetId(name: string, i: number): string;
+/**
+ * Return the union of table IDs from all selected subnets
+ */
+export declare function allRouteTableIds(subnets: ISubnet[]): string[];
+export declare function flatten<A>(xs: A[][]): A[];
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+export declare class NetworkUtils {
+    /**
+     * Validates an IPv4 address string.
+     *
+     * @param ipAddress The IPv4 address string to be validated.
+     * @returns True if the string is a valid IPv4 address, false otherwise.
+     * Validates an IPv4 string
+     *
+     * returns true of the string contains 4 numbers between 0-255 delimited by
+     * a `.` character
+     */
+    static validIp(ipAddress: string): boolean;
+    /**
+     * Converts a string representation of an IPv4 address to its corresponding numerical value.
+     *
+     * Uses the formula:
+     * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +
+     * (fourth octet)
+     *
+     * @param  ipAddress the IP address (e.g. 174.66.173.168)
+     * @returns the integer value of the IP address (e.g 2923605416)
+     */
+    static ipToNum(ipAddress: string): number;
+    /**
+     * Takes number and converts it to IPv4 address string
+     *
+     * Takes a number (e.g 2923605416) and converts it to an IPv4 address string
+     * currently only supports IPv4
+     *
+     * @param ipNum integer value of the IP address (e.g 2923605416)
+     * @returns IPv4 address (e.g. 174.66.173.168)
+     */
+    static numToIp(ipNum: number): string;
+}
+/**
+ * Exported class from VPC to support subnet filtering
+ * and CIDR validation
+ */
+export declare class CidrBlock {
+    /**
+     * Calculates the netmask for a given CIDR mask
+     *
+     * The netmask is a 32-bit binary value used to separate the network portion from the host portion of an IPv4 address.
+     * It is calculated based on the CIDR prefix length (the number of bits used to represent the network portion).
+     *
+     * For example:
+     * CidrBlock.calculateNetmask(24) returns '255.255.255.0'
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the netmask.
+      // Calculate the netmask by performing a bitwise NOT on the result of (2^32 - 2^(32 - mask))
+     * @returns The netmask string in IPv4 address format.
+     */
+    static calculateNetmask(mask: number): string;
+    /**
+     * Calculates the number IP addresses in a CIDR Mask
+     *
+     * For example:
+     * CidrBlock.calculateNetsize(16) returns 65536
+     *
+     * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the network size.
+     * CidrBlock.calculateNetsize(24) returns 256
+     */
+    static calculateNetsize(mask: number): number;
+    /**
+     * IP address in the CIDR block.
+     */
+    readonly cidr: string;
+    readonly mask: number;
+    readonly networkSize: number;
+    private readonly networkAddress;
+    constructor(cidr: string);
+    constructor(ipAddress: number, mask: number);
+    maxIp(): string;
+    minIp(): string;
+    minAddress(): number;
+    maxAddress(): number;
+    nextBlock(): CidrBlock;
+    containsCidr(other: CidrBlock): boolean;
+    /**
+     * Checks if two IP address ranges overlap.
+     *
+     * @param range1 The first IP address range represented as an array [start, end].
+     * @param range2 The second IP address range represented as an array [start, end].
+     * @returns True if the two IP address ranges overlap, false otherwise.
+     *
+     * Note: This method assumes that the start and end addresses are valid IPv4 addresses.
+     */
+    rangesOverlap(range1: [string, string], range2: [string, string]): boolean;
+}
+/**
+ * Class with helper functions to support
+ * Subnet Ipv6 Address Validation
+ *
+ * This class provides methods for working with IPv6 CIDR blocks, including calculating the minimum and maximum
+ * IP addresses in a CIDR block, and checking if two CIDR blocks overlap.
+ */
+export declare class CidrBlockIpv6 {
+    /**
+     * Ipv6 CIDR range
+     */
+    cidr: string;
+    /**
+     * The CIDR prefix length (number of bits used for the network portion of the address).
+     */
+    cidrPrefix: number;
+    private ipParts;
+    private networkBits;
+    private networkPart;
+    constructor(cidr: string);
+    private parseBigIntParts;
+    /**
+     * @returns Minimum IPv6 address for a provided CIDR
+     */
+    minIp(): string;
+    /**
+     * @returns Maximum IPv6 address for a provided CIDR
+     */
+    maxIp(): string;
+    private formatIPv6Part;
+    /**
+     *
+     * @param range1 Ipv6 CIDR range to compare
+     * @param range2 Ipv6 CIDR range to compare
+     * @returns true if two ranges overlap, false otherwise
+     */
+    rangesOverlap(range1: string, range2: string): boolean;
+    /**
+     *
+     * @param cidr
+     * @returns Range in the from of big int number [start, end]
+     */
+    private getIPv6Range;
+    /**
+     * @param ipv6Address
+     * @returns Converts given ipv6 address range to big int number
+     */
+    private ipv6ToNumber;
+}