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

package/lib/util.js

@@ -0,0 +1,310 @@
+"use strict";
+/*eslint no-bitwise: ["error", { "allow": ["~", "|", "<<", "&"] }] */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CidrBlockIpv6 = exports.CidrBlock = exports.NetworkUtils = exports.flatten = exports.allRouteTableIds = exports.subnetId = exports.subnetGroupNameFromConstructId = void 0;
+/**
+ * Return a subnet name from its construct ID
+ *
+ * All subnet names look like NAME <> "Subnet" <> INDEX
+ */
+function subnetGroupNameFromConstructId(subnet) {
+    return subnet.node.id.replace(/Subnet\d+$/, '');
+}
+exports.subnetGroupNameFromConstructId = subnetGroupNameFromConstructId;
+/**
+ * Make the subnet construct ID from a name and number
+ */
+function subnetId(name, i) {
+    return `${name}Subnet${i + 1}`;
+}
+exports.subnetId = subnetId;
+/**
+ * Return the union of table IDs from all selected subnets
+ */
+function allRouteTableIds(subnets) {
+    const ret = new Set();
+    for (const subnet of subnets) {
+        if (subnet.routeTable && subnet.routeTable.routeTableId) {
+            ret.add(subnet.routeTable.routeTableId);
+        }
+    }
+    return Array.from(ret);
+}
+exports.allRouteTableIds = allRouteTableIds;
+function flatten(xs) {
+    return Array.prototype.concat.apply([], xs);
+}
+exports.flatten = flatten;
+/**
+ * NetworkUtils contains helpers to work with network constructs (subnets/ranges)
+ */
+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) {
+        const octets = ipAddress.split('.');
+        if (octets.length !== 4) {
+            return false;
+        }
+        return octets.map((octet) => parseInt(octet, 10)).
+            every((octet) => octet >= 0 && octet <= 255);
+    }
+    /**
+     * 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) {
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not valid`);
+        }
+        return ipAddress
+            .split('.')
+            .reduce((p, c, i) => p + parseInt(c, 10) * 256 ** (3 - i), 0);
+    }
+    /**
+     * 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) {
+        // this all because bitwise math is signed
+        let remaining = ipNum;
+        const address = new Array();
+        for (let i = 0; i < 4; i++) {
+            if (remaining !== 0) {
+                address.push(Math.floor(remaining / 256 ** (3 - i)));
+                remaining = remaining % 256 ** (3 - i);
+            }
+            else {
+                address.push(0);
+            }
+        }
+        const ipAddress = address.join('.');
+        if (!this.validIp(ipAddress)) {
+            throw new Error(`${ipAddress} is not a valid IP Address`);
+        }
+        return ipAddress;
+    }
+}
+exports.NetworkUtils = NetworkUtils;
+/**
+ * Exported class from VPC to support subnet filtering
+ * and CIDR validation
+ */
+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) {
+        return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));
+    }
+    /**
+     * 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) {
+        return 2 ** (32 - mask);
+    }
+    constructor(ipAddressOrCidr, mask) {
+        if (typeof ipAddressOrCidr === 'string') {
+            this.mask = parseInt(ipAddressOrCidr.split('/')[1], 10);
+            this.networkAddress = NetworkUtils.ipToNum(ipAddressOrCidr.split('/')[0]) +
+                CidrBlock.calculateNetsize(this.mask) - 1;
+        }
+        else {
+            if (typeof mask === 'number') {
+                this.mask = mask;
+            }
+            else {
+                // this should be impossible
+                this.mask = 16;
+            }
+            this.networkAddress = ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;
+            this.networkSize = 2 ** (32 - this.mask);
+        }
+        this.networkSize = 2 ** (32 - this.mask);
+        this.cidr = `${this.minIp()}/${this.mask}`;
+    }
+    /*
+     * The maximum IP in the CIDR Block e.g. '10.0.8.255'
+     */
+    maxIp() {
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return NetworkUtils.numToIp(this.maxAddress());
+    }
+    /*
+     * Checks if this CIDR block fully contains the provided CIDR block.
+     *
+     * @param other The CIDR block to check for containment.
+     * @returns True if this CIDR block fully contains the provided CIDR block, false otherwise.
+     *
+     * The minimum IP in the CIDR Block e.g. '10.0.0.0'
+     */
+    minIp() {
+        return NetworkUtils.numToIp(this.minAddress());
+    }
+    /*
+     * Returns the number representation for the minimum IPv4 address
+     */
+    minAddress() {
+        const div = this.networkAddress % this.networkSize;
+        return this.networkAddress - div;
+    }
+    /*
+     * Returns the number representation for the maximum IPv4 address
+     */
+    maxAddress() {
+        /**
+         * The maximum IP address in the CIDR block is calculated as the minimum address + (2^(32-mask)) - 1.
+         * This is because the minimum address represents the network address, and the maximum address is the broadcast address.
+         */
+        // min + (2^(32-mask)) - 1 [zero needs to count]
+        return this.minAddress() + this.networkSize - 1;
+    }
+    /*
+     * Returns the next consecutive CIDR block of the same mask size following this CIDR block.
+     *
+     * For example, if this CIDR block is '10.0.0.0/24', the next block would be '10.0.1.0/24'.
+     *
+     * Returns the next CIDR Block of the same mask size
+     */
+    nextBlock() {
+        return new CidrBlock(this.maxAddress() + 1, this.mask);
+    }
+    /*
+     * Returns true if this CidrBlock fully contains the provided CidrBlock
+     */
+    containsCidr(other) {
+        return (this.maxAddress() >= other.maxAddress()) &&
+            (this.minAddress() <= other.minAddress());
+    }
+    /**
+     * 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, range2) {
+        const [start1, end1] = range1;
+        const [start2, end2] = range2;
+        // Check if ranges overlap
+        return start1 <= end2 && start2 <= end1;
+    }
+}
+exports.CidrBlock = CidrBlock;
+/**
+ * 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.
+ */
+class CidrBlockIpv6 {
+    constructor(cidr) {
+        this.formatIPv6Part = (part) => part.toString(16).padStart(4, '0');
+        this.cidr = cidr;
+        const [ipAddress, prefix] = cidr.split('/');
+        this.cidrPrefix = parseInt(prefix, 10);
+        this.ipParts = this.parseBigIntParts(ipAddress);
+        this.networkBits = this.cidrPrefix;
+        this.networkPart = this.ipParts.slice(0, Math.ceil(this.networkBits / 16));
+    }
+    parseBigIntParts(ipAddress) {
+        return ipAddress.split(':').map((part) => BigInt(`0x${part.padStart(4, '0')}` || '0'));
+    }
+    /**
+     * @returns Minimum IPv6 address for a provided CIDR
+     */
+    minIp() {
+        const startIP = [...this.networkPart];
+        for (let i = this.networkPart.length; i < 8; i++) {
+            startIP.push(BigInt(0));
+        }
+        return startIP.map(this.formatIPv6Part).join(':');
+    }
+    /**
+     * @returns Maximum IPv6 address for a provided CIDR
+     */
+    maxIp() {
+        const endIP = [...this.networkPart];
+        const hostPart = Array(8 - this.networkPart.length).fill(BigInt(0xffff));
+        endIP.push(...hostPart);
+        return endIP.map(this.formatIPv6Part).join(':');
+    }
+    /**
+     *
+     * @param range1 Ipv6 CIDR range to compare
+     * @param range2 Ipv6 CIDR range to compare
+     * @returns true if two ranges overlap, false otherwise
+     */
+    rangesOverlap(range1, range2) {
+        const [start1, end1] = this.getIPv6Range(range1);
+        const [start2, end2] = this.getIPv6Range(range2);
+        return (start1 <= end2) && (start2 <= end1);
+    }
+    /**
+     *
+     * @param cidr
+     * @returns Range in the from of big int number [start, end]
+     */
+    getIPv6Range(cidr) {
+        const [ipv6Address, prefixLength] = cidr.split('/');
+        const ipv6Number = this.ipv6ToNumber(ipv6Address);
+        const mask = (BigInt(1) << BigInt(128 - Number(prefixLength))) - BigInt(1);
+        const networkPrefix = ipv6Number & ~mask;
+        const start = networkPrefix;
+        const end = networkPrefix | mask;
+        return [start, end];
+    }
+    /**
+     * @param ipv6Address
+     * @returns Converts given ipv6 address range to big int number
+     */
+    ipv6ToNumber(ipv6Address) {
+        const blocks = this.parseBigIntParts(ipv6Address);
+        let ipv6Number = BigInt(0);
+        for (const block of blocks) {
+            /* tslint:disable:no-bitwise */
+            ipv6Number = (ipv6Number << BigInt(16)) + block;
+        }
+        return ipv6Number;
+    }
+}
+exports.CidrBlockIpv6 = CidrBlockIpv6;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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","sourcesContent":["/*eslint no-bitwise: [\"error\", { \"allow\": [\"~\", \"|\", \"<<\", \"&\"] }] */\n\nimport { ISubnet } from 'aws-cdk-lib/aws-ec2';\n\n/**\n * Return a subnet name from its construct ID\n *\n * All subnet names look like NAME <> \"Subnet\" <> INDEX\n */\nexport function subnetGroupNameFromConstructId(subnet: ISubnet) {\n  return subnet.node.id.replace(/Subnet\\d+$/, '');\n}\n\n/**\n * Make the subnet construct ID from a name and number\n */\nexport function subnetId(name: string, i: number) {\n  return `${name}Subnet${i + 1}`;\n}\n\n/**\n * Return the union of table IDs from all selected subnets\n */\nexport function allRouteTableIds(subnets: ISubnet[]): string[] {\n  const ret = new Set<string>();\n  for (const subnet of subnets) {\n    if (subnet.routeTable && subnet.routeTable.routeTableId) {\n      ret.add(subnet.routeTable.routeTableId);\n    }\n  }\n  return Array.from(ret);\n}\n\nexport function flatten<A>(xs: A[][]): A[] {\n  return Array.prototype.concat.apply([], xs);\n}\n\n/**\n * NetworkUtils contains helpers to work with network constructs (subnets/ranges)\n */\nexport class NetworkUtils {\n\n  /**\n   * Validates an IPv4 address string.\n   *\n   * @param ipAddress The IPv4 address string to be validated.\n   * @returns True if the string is a valid IPv4 address, false otherwise.\n   * Validates an IPv4 string\n   *\n   * returns true of the string contains 4 numbers between 0-255 delimited by\n   * a `.` character\n   */\n  public static validIp(ipAddress: string): boolean {\n    const octets = ipAddress.split('.');\n    if (octets.length !== 4) {\n      return false;\n    }\n    return octets.map((octet: string) => parseInt(octet, 10)).\n      every((octet: number) => octet >= 0 && octet <= 255);\n  }\n\n  /**\n   * Converts a string representation of an IPv4 address to its corresponding numerical value.\n   *\n   * Uses the formula:\n   * (first octet * 256³) + (second octet * 256²) + (third octet * 256) +\n   * (fourth octet)\n   *\n   * @param  ipAddress the IP address (e.g. 174.66.173.168)\n   * @returns the integer value of the IP address (e.g 2923605416)\n   */\n  public static ipToNum(ipAddress: string): number {\n    if (!this.validIp(ipAddress)) {\n      throw new Error(`${ipAddress} is not valid`);\n    }\n\n    return ipAddress\n      .split('.')\n      .reduce(\n        (p: number, c: string, i: number) => p + parseInt(c, 10) * 256 ** (3 - i),\n        0,\n      );\n  }\n\n  /**\n   * Takes number and converts it to IPv4 address string\n   *\n   * Takes a number (e.g 2923605416) and converts it to an IPv4 address string\n   * currently only supports IPv4\n   *\n   * @param ipNum integer value of the IP address (e.g 2923605416)\n   * @returns IPv4 address (e.g. 174.66.173.168)\n   */\n  public static numToIp(ipNum: number): string {\n    // this all because bitwise math is signed\n    let remaining = ipNum;\n    const address = new Array<number>();\n    for (let i = 0; i < 4; i++) {\n      if (remaining !== 0) {\n        address.push(Math.floor(remaining / 256 ** (3 - i)));\n        remaining = remaining % 256 ** (3 - i);\n      } else {\n        address.push(0);\n      }\n    }\n    const ipAddress: string = address.join('.');\n    if ( !this.validIp(ipAddress) ) {\n      throw new Error(`${ipAddress} is not a valid IP Address`);\n    }\n    return ipAddress;\n  }\n}\n\n/**\n * Exported class from VPC to support subnet filtering\n * and CIDR validation\n */\nexport class CidrBlock {\n\n  /**\n   * Calculates the netmask for a given CIDR mask\n   *\n   * The netmask is a 32-bit binary value used to separate the network portion from the host portion of an IPv4 address.\n   * It is calculated based on the CIDR prefix length (the number of bits used to represent the network portion).\n   *\n   * For example:\n   * CidrBlock.calculateNetmask(24) returns '255.255.255.0'\n   *\n   * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the netmask.\n    // Calculate the netmask by performing a bitwise NOT on the result of (2^32 - 2^(32 - mask))\n   * @returns The netmask string in IPv4 address format.\n   */\n  public static calculateNetmask(mask: number): string {\n    return NetworkUtils.numToIp(2 ** 32 - 2 ** (32 - mask));\n  }\n\n  /**\n   * Calculates the number IP addresses in a CIDR Mask\n   *\n   * For example:\n   * CidrBlock.calculateNetsize(16) returns 65536\n   *\n   * @param mask The CIDR prefix length (between 0 and 32) for which to calculate the network size.\n   * CidrBlock.calculateNetsize(24) returns 256\n   */\n  public static calculateNetsize(mask: number): number {\n    return 2 ** (32 - mask);\n  }\n\n  /**\n   * IP address in the CIDR block.\n   */\n  public readonly cidr: string;\n\n  /*\n   * The CIDR mask e.g. for CIDR '10.0.0.0/21' returns 21\n   */\n  public readonly mask: number;\n\n  /*\n   * The total number of IP addresses in the CIDR\n   */\n  public readonly networkSize: number;\n\n  /*\n   * The network address provided in CIDR creation offset by the Netsize -1\n   */\n  private readonly networkAddress: number;\n\n  /*\n   * Parses either CIDR notation String or two numbers representing the IP\n   * space\n   *\n   * cidr expects a string '10.0.0.0/16'\n   * ipAddress expects a number\n   * mask expects a number\n   *\n   * If the given `cidr` or `ipAddress` is not the beginning of the block,\n   * then the next available block will be returned. For example, if\n   * `10.0.3.1/28` is given the returned block will represent `10.0.3.16/28`.\n   */\n  constructor(cidr: string)\n  constructor(ipAddress: number, mask: number)\n  constructor(ipAddressOrCidr: string | number, mask?: number) {\n    if (typeof ipAddressOrCidr === 'string') {\n      this.mask = parseInt(ipAddressOrCidr.split('/')[1], 10);\n      this.networkAddress = NetworkUtils.ipToNum(ipAddressOrCidr.split('/')[0]) +\n        CidrBlock.calculateNetsize(this.mask) - 1;\n    } else {\n      if (typeof mask === 'number') {\n        this.mask = mask;\n      } else {\n        // this should be impossible\n        this.mask = 16;\n      }\n      this.networkAddress = ipAddressOrCidr + CidrBlock.calculateNetsize(this.mask) - 1;\n      this.networkSize = 2 ** (32 - this.mask);\n    }\n    this.networkSize = 2 ** (32 - this.mask);\n    this.cidr = `${this.minIp()}/${this.mask}`;\n  }\n\n  /*\n   * The maximum IP in the CIDR Block e.g. '10.0.8.255'\n   */\n  public maxIp(): string {\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return NetworkUtils.numToIp(this.maxAddress());\n  }\n\n  /*\n   * Checks if this CIDR block fully contains the provided CIDR block.\n   *\n   * @param other The CIDR block to check for containment.\n   * @returns True if this CIDR block fully contains the provided CIDR block, false otherwise.\n   *\n   * The minimum IP in the CIDR Block e.g. '10.0.0.0'\n   */\n  public minIp(): string {\n    return NetworkUtils.numToIp(this.minAddress());\n  }\n\n  /*\n   * Returns the number representation for the minimum IPv4 address\n   */\n  public minAddress(): number {\n    const div = this.networkAddress % this.networkSize;\n    return this.networkAddress - div;\n  }\n\n  /*\n   * Returns the number representation for the maximum IPv4 address\n   */\n  public maxAddress(): number {\n    /**\n     * The maximum IP address in the CIDR block is calculated as the minimum address + (2^(32-mask)) - 1.\n     * This is because the minimum address represents the network address, and the maximum address is the broadcast address.\n     */\n    // min + (2^(32-mask)) - 1 [zero needs to count]\n    return this.minAddress() + this.networkSize - 1;\n  }\n\n  /*\n   * Returns the next consecutive CIDR block of the same mask size following this CIDR block.\n   *\n   * For example, if this CIDR block is '10.0.0.0/24', the next block would be '10.0.1.0/24'.\n   *\n   * Returns the next CIDR Block of the same mask size\n   */\n  public nextBlock(): CidrBlock {\n    return new CidrBlock(this.maxAddress() + 1, this.mask);\n  }\n\n  /*\n   * Returns true if this CidrBlock fully contains the provided CidrBlock\n   */\n  public containsCidr(other: CidrBlock): boolean {\n    return (this.maxAddress() >= other.maxAddress()) &&\n      (this.minAddress() <= other.minAddress());\n  }\n\n  /**\n   * Checks if two IP address ranges overlap.\n   *\n   * @param range1 The first IP address range represented as an array [start, end].\n   * @param range2 The second IP address range represented as an array [start, end].\n   * @returns True if the two IP address ranges overlap, false otherwise.\n   *\n   * Note: This method assumes that the start and end addresses are valid IPv4 addresses.\n   */\n  public rangesOverlap(range1: [string, string], range2: [string, string]): boolean {\n    const [start1, end1] = range1;\n    const [start2, end2] = range2;\n\n    // Check if ranges overlap\n    return start1 <= end2 && start2 <= end1;\n  }\n\n}\n\n/**\n * Class with helper functions to support\n * Subnet Ipv6 Address Validation\n *\n * This class provides methods for working with IPv6 CIDR blocks, including calculating the minimum and maximum\n * IP addresses in a CIDR block, and checking if two CIDR blocks overlap.\n */\nexport class CidrBlockIpv6 {\n\n  /**\n   * Ipv6 CIDR range\n   */\n  public cidr: string;\n  /**\n   * The CIDR prefix length (number of bits used for the network portion of the address).\n   */\n  public cidrPrefix: number;\n  private ipParts: bigint[];\n  private networkBits: number;\n  private networkPart: bigint[];\n\n  constructor(cidr: string) {\n    this.cidr = cidr;\n    const [ipAddress, prefix] = cidr.split('/');\n    this.cidrPrefix = parseInt(prefix, 10);\n    this.ipParts = this.parseBigIntParts(ipAddress);\n    this.networkBits = this.cidrPrefix;\n    this.networkPart = this.ipParts.slice(0, Math.ceil(this.networkBits / 16));\n  }\n\n  private parseBigIntParts(ipAddress: string): bigint[] {\n    return ipAddress.split(':').map((part) => BigInt(`0x${part.padStart(4, '0')}` || '0'));\n  }\n\n  /**\n   * @returns Minimum IPv6 address for a provided CIDR\n   */\n  public minIp(): string {\n    const startIP = [...this.networkPart];\n    for (let i = this.networkPart.length; i < 8; i++) {\n      startIP.push(BigInt(0));\n    }\n    return startIP.map(this.formatIPv6Part).join(':');\n  }\n\n  /**\n   * @returns Maximum IPv6 address for a provided CIDR\n   */\n  public maxIp(): string {\n    const endIP = [...this.networkPart];\n    const hostPart = Array(8 - this.networkPart.length).fill(BigInt(0xffff));\n    endIP.push(...hostPart);\n\n    return endIP.map(this.formatIPv6Part).join(':');\n  }\n\n  private formatIPv6Part = (part: bigint) => part.toString(16).padStart(4, '0');\n\n  /**\n   *\n   * @param range1 Ipv6 CIDR range to compare\n   * @param range2 Ipv6 CIDR range to compare\n   * @returns true if two ranges overlap, false otherwise\n   */\n  public rangesOverlap(range1: string, range2: string): boolean {\n    const [start1, end1] = this.getIPv6Range(range1);\n    const [start2, end2] = this.getIPv6Range(range2);\n\n    return (start1 <= end2) && (start2 <= end1);\n  }\n\n  /**\n   *\n   * @param cidr\n   * @returns Range in the from of big int number [start, end]\n   */\n  private getIPv6Range(cidr: string): [bigint, bigint] {\n    const [ipv6Address, prefixLength] = cidr.split('/');\n    const ipv6Number = this.ipv6ToNumber(ipv6Address);\n    const mask = (BigInt(1) << BigInt(128 - Number(prefixLength))) - BigInt(1);\n    const networkPrefix = ipv6Number & ~mask;\n    const start = networkPrefix;\n    const end = networkPrefix | mask;\n\n    return [start, end];\n  }\n\n  /**\n   * @param ipv6Address\n   * @returns Converts given ipv6 address range to big int number\n   */\n  private ipv6ToNumber(ipv6Address: string): bigint {\n    const blocks = this.parseBigIntParts(ipv6Address);\n    let ipv6Number = BigInt(0);\n    for (const block of blocks) {\n      /* tslint:disable:no-bitwise */\n      ipv6Number = (ipv6Number << BigInt(16)) + block;\n    }\n    return ipv6Number;\n  }\n}\n\n"]}

package/lib/vpc-v2-base.d.ts

@@ -0,0 +1,132 @@
+import { Resource } from 'aws-cdk-lib';
+import { IVpc, ISubnet, SubnetSelection, SelectedSubnets, EnableVpnGatewayOptions, VpnConnectionOptions, VpnConnection, ClientVpnEndpointOptions, ClientVpnEndpoint, InterfaceVpcEndpointOptions, InterfaceVpcEndpoint, GatewayVpcEndpointOptions, GatewayVpcEndpoint, FlowLogOptions, FlowLog, CfnVPCCidrBlock } from 'aws-cdk-lib/aws-ec2';
+import { IDependable } from 'constructs';
+/**
+ * Placeholder to see what extra props we might need,
+ * will be added to original IVPC
+ */
+export interface IVpcV2 extends IVpc {
+    /**
+     * The secondary CIDR blocks associated with the VPC.
+     *
+     * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.
+     */
+    readonly secondaryCidrBlock: CfnVPCCidrBlock[];
+    /**
+     * The primary IPv4 CIDR block associated with the VPC.
+     * Needed in order to validate the vpc range of subnet
+     * current prop vpcCidrBlock refers to the token value
+     * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.
+     */
+    readonly ipv4CidrBlock: string;
+}
+/**
+ * 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}.
+ */
+export declare abstract class VpcV2Base extends Resource implements IVpcV2 {
+    /**
+    * Identifier for this VPC
+    */
+    abstract readonly vpcId: string;
+    /**
+    * Arn of this VPC
+    */
+    abstract readonly vpcArn: string;
+    /**
+    * CIDR range for this VPC
+    */
+    abstract readonly vpcCidrBlock: string;
+    /**
+    * List of public subnets in this VPC
+    */
+    readonly publicSubnets: ISubnet[];
+    /**
+    * List of private subnets in this VPC
+    */
+    readonly privateSubnets: ISubnet[];
+    /**
+    * List of isolated subnets in this VPC
+    */
+    abstract readonly isolatedSubnets: ISubnet[];
+    /**
+    * AZs for this VPC
+    */
+    readonly availabilityZones: string[];
+    /**
+    * Dependable that can be depended upon to force internet connectivity established on the VPC
+    */
+    abstract readonly internetConnectivityEstablished: IDependable;
+    /**
+     * Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6
+     * Ipv4 should be within RFC#1918 range
+     */
+    abstract readonly secondaryCidrBlock: CfnVPCCidrBlock[];
+    /**
+     * The primary IPv4 CIDR block associated with the VPC.
+     * Needed in order to validate the vpc range of subnet
+     * current prop vpcCidrBlock refers to the token value
+     * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.
+     */
+    abstract readonly ipv4CidrBlock: string;
+    /**
+    * If this is set to true, don't error out on trying to select subnets
+    */
+    protected incompleteSubnetDefinition: boolean;
+    /**
+     * Mutable private field for the vpnGatewayId
+     *
+     * @internal
+     */
+    protected _vpnGatewayId?: string;
+    /**
+    * 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?: SubnetSelection): SelectedSubnets;
+    /**
+    * Adds a VPN Gateway to this VPC
+    */
+    enableVpnGateway(options: EnableVpnGatewayOptions): void;
+    /**
+    * Adds a new VPN connection to this VPC
+    */
+    addVpnConnection(id: string, options: VpnConnectionOptions): VpnConnection;
+    /**
+    * Adds a new client VPN endpoint to this VPC
+    */
+    addClientVpnEndpoint(id: string, options: ClientVpnEndpointOptions): ClientVpnEndpoint;
+    /**
+    * Adds a new interface endpoint to this VPC
+    */
+    addInterfaceEndpoint(id: string, options: InterfaceVpcEndpointOptions): InterfaceVpcEndpoint;
+    /**
+    * Adds a new gateway endpoint to this VPC
+    */
+    addGatewayEndpoint(id: string, options: GatewayVpcEndpointOptions): GatewayVpcEndpoint;
+    /**
+    * Adds a new flow log to this VPC
+    */
+    addFlowLog(id: string, options?: FlowLogOptions): FlowLog;
+    /**
+    * Returns the id of the VPN Gateway (if enabled)
+    */
+    get vpnGatewayId(): string | undefined;
+    /**
+    * Return the subnets appropriate for the placement strategy
+    */
+    protected selectSubnetObjects(selection?: SubnetSelection): ISubnet[];
+    private applySubnetFilters;
+    private selectSubnetObjectsByName;
+    private selectSubnetObjectsByType;
+    /**
+    * 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.
+    */
+    private reifySelectionDefaults;
+}