terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/ip-addresses.js

@@ -0,0 +1,248 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ipv6Addresses = exports.IpAddresses = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/ip-addresses.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const cidr_splits_1 = require("./cidr-splits");
+const network_util_1 = require("./network-util");
+/**
+ * An abstract Provider of IpAddresses
+ *
+ * Note this is specific to the IPv4 CIDR.
+ */
+class IpAddresses {
+    /**
+     * Used to provide local Ip Address Management services for your VPC
+     *
+     * VPC CIDR is supplied at creation and subnets are calculated locally
+     *
+     * Note this is specific to the IPv4 CIDR.
+     *
+     */
+    static cidr(cidrBlock) {
+        return new Cidr(cidrBlock);
+    }
+    /**
+     * Used to provide centralized Ip Address Management services for your VPC
+     *
+     * Uses VPC CIDR allocations from AWS IPAM
+     *
+     * Note this is specific to the IPv4 CIDR.
+     *
+     * @see https://docs.aws.amazon.com/vpc/latest/ipam/what-it-is-ipam.html
+     */
+    static awsIpamAllocation(props) {
+        return new AwsIpam(props);
+    }
+    constructor() { }
+}
+exports.IpAddresses = IpAddresses;
+_a = JSII_RTTI_SYMBOL_1;
+IpAddresses[_a] = { fqn: "terraconstructs.aws.compute.IpAddresses", version: "0.0.12" };
+/**
+ * Implements integration with Amazon VPC IP Address Manager (IPAM).
+ *
+ * See the package-level documentation of this package for an overview
+ * of the various dimensions in which you can configure your VPC.
+ *
+ * For example:
+ *
+ * ```ts
+ *  new compute.Vpc(stack, 'TheVPC', {
+ *   ipAddresses: IpAddresses.awsIpamAllocation({
+ *     ipv4IpamPoolId: pool.ref,
+ *     ipv4NetmaskLength: 18,
+ *     defaultSubnetIpv4NetmaskLength: 24
+ *   })
+ * });
+ * ```
+ *
+ */
+class AwsIpam {
+    constructor(props) {
+        this.props = props;
+    }
+    /**
+     * Allocates Vpc CIDR. called when creating a Vpc using AwsIpam.
+     */
+    allocateVpcCidr() {
+        return {
+            ipv4NetmaskLength: this.props.ipv4NetmaskLength,
+            ipv4IpamPoolId: this.props.ipv4IpamPoolId,
+        };
+    }
+    /**
+     * Allocates Subnets CIDRs. Called by VPC when creating subnets.
+     */
+    allocateSubnetsCidr(input) {
+        const cidrSplit = (0, cidr_splits_1.calculateCidrSplits)(this.props.ipv4NetmaskLength, input.requestedSubnets.map((mask) => {
+            if (mask.configuration.cidrMask === undefined &&
+                this.props.defaultSubnetIpv4NetmaskLength === undefined) {
+                throw new Error("If you have not set a cidr for all subnets in this case you must set a defaultCidrMask in AwsIpam Options");
+            }
+            const cidrMask = mask.configuration.cidrMask ??
+                this.props.defaultSubnetIpv4NetmaskLength;
+            if (cidrMask === undefined) {
+                throw new Error("Should not have happened, but satisfies the type checker");
+            }
+            return cidrMask;
+        }));
+        const allocatedSubnets = cidrSplit.map((subnet) => {
+            return {
+                cidr: cdktf_1.Fn.cidrsubnet(input.vpcCidr, subnet.newbits, subnet.index),
+            };
+        });
+        return {
+            allocatedSubnets: allocatedSubnets,
+        };
+    }
+}
+/**
+ * Implements static Ip assignment locally.
+ *
+ * See the package-level documentation of this package for an overview
+ * of the various dimensions in which you can configure your VPC.
+ *
+ * For example:
+ *
+ * ```ts
+ *  new compute.Vpc(stack, 'TheVPC', {
+ *   ipAddresses: compute.IpAddresses.cidr('10.0.1.0/20')
+ * });
+ * ```
+ *
+ */
+class Cidr {
+    constructor(cidrBlock) {
+        this.cidrBlock = cidrBlock;
+        if (cdktf_1.Token.isUnresolved(cidrBlock)) {
+            throw new Error("'cidr' property must be a concrete CIDR string, got a Token (we need to parse it for automatic subdivision)");
+        }
+        this.networkBuilder = new network_util_1.NetworkBuilder(this.cidrBlock);
+    }
+    /**
+     * Allocates Vpc CIDR. Called when creating a Vpc using IpAddresses.cidr.
+     */
+    allocateVpcCidr() {
+        return {
+            cidrBlock: this.networkBuilder.networkCidr.cidr,
+        };
+    }
+    /**
+     * Allocates Subnets Cidrs. Called by VPC when creating subnets.
+     */
+    allocateSubnetsCidr(input) {
+        const allocatedSubnets = [];
+        const subnetsWithoutDefinedCidr = [];
+        //default: Available IP space is evenly divided across subnets if no cidr is given.
+        input.requestedSubnets.forEach((requestedSubnet, index) => {
+            if (requestedSubnet.configuration.cidrMask === undefined) {
+                subnetsWithoutDefinedCidr.push({
+                    index,
+                    requestedSubnet,
+                });
+            }
+            else {
+                allocatedSubnets.push({
+                    cidr: this.networkBuilder.addSubnet(requestedSubnet.configuration.cidrMask),
+                });
+            }
+        });
+        const cidrMaskForRemaining = this.networkBuilder.maskForRemainingSubnets(subnetsWithoutDefinedCidr.length);
+        subnetsWithoutDefinedCidr.forEach((subnet) => {
+            allocatedSubnets.splice(subnet.index, 0, {
+                cidr: this.networkBuilder.addSubnet(cidrMaskForRemaining),
+            });
+        });
+        return {
+            allocatedSubnets: allocatedSubnets,
+        };
+    }
+}
+/**
+ * An abstract Provider of Ipv6Addresses.
+ *
+ * Note this is specific to the IPv6 CIDR.
+ */
+class Ipv6Addresses {
+    /**
+     * Used for IPv6 address management with Amazon provided CIDRs.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    static amazonProvided() {
+        return new AmazonProvided();
+    }
+    constructor() { }
+}
+exports.Ipv6Addresses = Ipv6Addresses;
+_b = JSII_RTTI_SYMBOL_1;
+Ipv6Addresses[_b] = { fqn: "terraconstructs.aws.compute.Ipv6Addresses", version: "0.0.12" };
+/**
+ * Implements integration with Amazon provided IPv6 CIDRs.
+ *
+ * Note this is specific to the IPv6 CIDR.
+ */
+class AmazonProvided {
+    constructor() {
+        this.amazonProvided = true;
+    }
+    /**
+     * Called by VPC to allocate IPv6 CIDR.
+     *
+     * Creates an Amazon provided CIDR block.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    allocateVpcIpv6Cidr(input) {
+        //throw new Error(`vpcId not found, got ${(scope as any).vpcId}`);
+        return new provider_aws_1.vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation(input.scope, "ipv6cidr", {
+            vpcId: input.vpcId,
+            assignGeneratedIpv6CidrBlock: this.amazonProvided,
+        });
+    }
+    /**
+     * Split IPv6 CIDR block up for subnets.
+     *
+     * Called by VPC when creating subnets with IPv6 enabled.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    createIpv6CidrBlocks(input) {
+        let parentMask = input.parentMask ?? 56;
+        if (!cdktf_1.Token.isUnresolved(input.ipv6SelectedCidr)) {
+            parentMask = parseInt(input.ipv6SelectedCidr.split("/")[1], 10);
+            if (Number.isNaN(parentMask)) {
+                throw new Error(`Parent CIDR must include a valid mask, got: '${input.ipv6SelectedCidr}'`);
+            }
+        }
+        const sizeMask = parseInt(input.sizeMask ?? "64"); // 128 - 64
+        const newbits = sizeMask - parentMask;
+        return cdktf_1.Fn.cidrsubnets(input.ipv6SelectedCidr, Array.from({ length: input.subnetCount }, () => newbits));
+    }
+    /**
+     * Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.
+     *
+     * This function takes the list of allocated subnets,
+     * and copies the IPv4 CIDRs while also assigning the IPv6 CIDR.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    allocateSubnetsIpv6Cidr(input) {
+        const allocatedSubnets = [];
+        input.allocatedSubnets.forEach((allocated, i) => {
+            const allocatedIpv6 = {
+                cidr: allocated.cidr,
+                ipv6Cidr: cdktf_1.Fn.element(input.ipv6Cidrs, i),
+            };
+            allocatedSubnets.push(allocatedIpv6);
+        });
+        return {
+            allocatedSubnets: allocatedSubnets,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ip-addresses.js","sourceRoot":"","sources":["../../../src/aws/compute/ip-addresses.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/ip-addresses.ts\n\nimport {\n  // vpcIpv4CidrBlockAssociation,\n  vpcIpv6CidrBlockAssociation,\n} from \"@cdktf/provider-aws\";\nimport { Fn, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { calculateCidrSplits } from \"./cidr-splits\";\nimport { NetworkBuilder } from \"./network-util\";\nimport { SubnetConfiguration } from \"./vpc\";\n\n/**\n * An abstract Provider of IpAddresses\n *\n * Note this is specific to the IPv4 CIDR.\n */\nexport class IpAddresses {\n  /**\n   * Used to provide local Ip Address Management services for your VPC\n   *\n   * VPC CIDR is supplied at creation and subnets are calculated locally\n   *\n   * Note this is specific to the IPv4 CIDR.\n   *\n   */\n  public static cidr(cidrBlock: string): IIpAddresses {\n    return new Cidr(cidrBlock);\n  }\n\n  /**\n   * Used to provide centralized Ip Address Management services for your VPC\n   *\n   * Uses VPC CIDR allocations from AWS IPAM\n   *\n   * Note this is specific to the IPv4 CIDR.\n   *\n   * @see https://docs.aws.amazon.com/vpc/latest/ipam/what-it-is-ipam.html\n   */\n  public static awsIpamAllocation(props: AwsIpamProps): IIpAddresses {\n    return new AwsIpam(props);\n  }\n\n  private constructor() {}\n}\n\n/**\n * Implementations for ip address management.\n *\n * Note this is specific to the IPv4 CIDR.\n */\nexport interface IIpAddresses {\n  /**\n   * Called by the VPC to retrieve VPC options from the Ipam\n   *\n   * Don't call this directly, the VPC will call it automatically.\n   */\n  allocateVpcCidr(): VpcIpamOptions;\n\n  /**\n   * Called by the VPC to retrieve Subnet options from the Ipam\n   *\n   * Don't call this directly, the VPC will call it automatically.\n   */\n  allocateSubnetsCidr(input: AllocateCidrRequest): SubnetIpamOptions;\n}\n\n/**\n * CIDR Allocated Vpc\n */\nexport interface VpcIpamOptions {\n  /**\n   * CIDR Block for Vpc\n   *\n   * @default - Only required when Ipam has concrete allocation available for static Vpc\n   */\n  readonly cidrBlock?: string;\n\n  /**\n   * CIDR Mask for Vpc\n   *\n   * @default - Only required when using AWS Ipam\n   */\n  readonly ipv4NetmaskLength?: number;\n\n  /**\n   * ipv4 IPAM Pool Id\n   *\n   * @default - Only required when using AWS Ipam\n   */\n  readonly ipv4IpamPoolId?: string;\n}\n\n/**\n * Subnet requested for allocation\n */\nexport interface RequestedSubnet {\n  /**\n   * The availability zone for the subnet\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * Specify configuration parameters for a single subnet group in a VPC\n   */\n  readonly configuration: SubnetConfiguration;\n\n  /**\n   * Id for the Subnet construct\n   */\n  readonly subnetConstructId: string;\n}\n\n/**\n * An instance of a Subnet requested for allocation\n */\ninterface IRequestedSubnetInstance {\n  /**\n   * Index location of Subnet requested for allocation\n   */\n  readonly index: number;\n\n  /**\n   * Subnet requested for allocation\n   */\n  readonly requestedSubnet: RequestedSubnet;\n}\n\n/**\n * Request for subnets CIDR to be allocated for a Vpc\n */\nexport interface AllocateCidrRequest {\n  /**\n   * The IPv4 CIDR block for this Vpc\n   */\n  readonly vpcCidr: string;\n\n  /**\n   * The Subnets to be allocated\n   */\n  readonly requestedSubnets: RequestedSubnet[];\n}\n\n/**\n * Request for allocation of the VPC IPv6 CIDR.\n */\nexport interface AllocateVpcIpv6CidrRequest {\n  /**\n   * The VPC construct to attach to.\n   */\n  readonly scope: Construct;\n\n  /**\n   * The id of the VPC.\n   */\n  readonly vpcId: string;\n}\n\n/**\n * Request for IPv6 CIDR block to be split up.\n */\nexport interface CreateIpv6CidrBlocksRequest {\n  /**\n   * The IPv6 CIDR block string representation.\n   */\n  readonly ipv6SelectedCidr: string;\n\n  /**\n   * The number of subnets to assign CIDRs to.\n   */\n  readonly subnetCount: number;\n\n  /**\n   * Size of the covered bits in the CIDR.\n   * @default - 128 - 64 = /64 CIDR.\n   */\n  readonly sizeMask?: string;\n\n  /**\n   * The parent mask of the CIDR.\n   *\n   * Valid values are from 44 to 60 in increments of 4.\n   *\n   * @default - 56\n   */\n  readonly parentMask?: number;\n}\n\n/**\n * Request for subnet IPv6 CIDRs to be allocated for a VPC.\n */\nexport interface AllocateIpv6CidrRequest {\n  /**\n   * List of subnets allocated with IPv4 CIDRs\n   */\n  readonly allocatedSubnets: AllocatedSubnet[];\n\n  /**\n   * The IPv6 CIDRs to be allocated to the subnets\n   */\n  readonly ipv6Cidrs: string[];\n}\n\n/**\n * CIDR Allocated Subnets\n */\nexport interface SubnetIpamOptions {\n  /**\n   * CIDR Allocations for Subnets\n   */\n  readonly allocatedSubnets: AllocatedSubnet[];\n}\n\n/**\n * CIDR Allocated Subnet\n */\nexport interface AllocatedSubnet {\n  /**\n   * IPv4 CIDR Allocations for a Subnet.\n   *\n   * Note this is specific to the IPv4 CIDR.\n   */\n  readonly cidr: string;\n\n  /**\n   * IPv6 CIDR Allocations for a Subnet.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   *\n   * @default - no IPV6 CIDR\n   */\n  readonly ipv6Cidr?: string;\n}\n\n/**\n * Configuration for AwsIpam\n */\nexport interface AwsIpamProps {\n  /**\n   * Netmask length for Vpc\n   */\n  readonly ipv4NetmaskLength: number;\n\n  /**\n   * Ipam Pool Id for ipv4 allocation\n   */\n  readonly ipv4IpamPoolId: string; // todo: should be a type\n\n  /**\n   * Default length for Subnet ipv4 Network mask\n   *\n   * Specify this option only if you do not specify all Subnets using SubnetConfiguration with a cidrMask\n   *\n   * @default - Default ipv4 Subnet Mask for subnets in Vpc\n   *\n   */\n  readonly defaultSubnetIpv4NetmaskLength?: number;\n}\n\n/**\n * Implements integration with Amazon VPC IP Address Manager (IPAM).\n *\n * See the package-level documentation of this package for an overview\n * of the various dimensions in which you can configure your VPC.\n *\n * For example:\n *\n * ```ts\n *  new compute.Vpc(stack, 'TheVPC', {\n *   ipAddresses: IpAddresses.awsIpamAllocation({\n *     ipv4IpamPoolId: pool.ref,\n *     ipv4NetmaskLength: 18,\n *     defaultSubnetIpv4NetmaskLength: 24\n *   })\n * });\n * ```\n *\n */\nclass AwsIpam implements IIpAddresses {\n  constructor(private readonly props: AwsIpamProps) {}\n\n  /**\n   * Allocates Vpc CIDR. called when creating a Vpc using AwsIpam.\n   */\n  allocateVpcCidr(): VpcIpamOptions {\n    return {\n      ipv4NetmaskLength: this.props.ipv4NetmaskLength,\n      ipv4IpamPoolId: this.props.ipv4IpamPoolId,\n    };\n  }\n\n  /**\n   * Allocates Subnets CIDRs. Called by VPC when creating subnets.\n   */\n  allocateSubnetsCidr(input: AllocateCidrRequest): SubnetIpamOptions {\n    const cidrSplit = calculateCidrSplits(\n      this.props.ipv4NetmaskLength,\n      input.requestedSubnets.map((mask) => {\n        if (\n          mask.configuration.cidrMask === undefined &&\n          this.props.defaultSubnetIpv4NetmaskLength === undefined\n        ) {\n          throw new Error(\n            \"If you have not set a cidr for all subnets in this case you must set a defaultCidrMask in AwsIpam Options\",\n          );\n        }\n\n        const cidrMask =\n          mask.configuration.cidrMask ??\n          this.props.defaultSubnetIpv4NetmaskLength;\n\n        if (cidrMask === undefined) {\n          throw new Error(\n            \"Should not have happened, but satisfies the type checker\",\n          );\n        }\n\n        return cidrMask;\n      }),\n    );\n\n    const allocatedSubnets: AllocatedSubnet[] = cidrSplit.map((subnet) => {\n      return {\n        cidr: Fn.cidrsubnet(input.vpcCidr, subnet.newbits, subnet.index),\n      };\n    });\n\n    return {\n      allocatedSubnets: allocatedSubnets,\n    };\n  }\n}\n\n/**\n * Implements static Ip assignment locally.\n *\n * See the package-level documentation of this package for an overview\n * of the various dimensions in which you can configure your VPC.\n *\n * For example:\n *\n * ```ts\n *  new compute.Vpc(stack, 'TheVPC', {\n *   ipAddresses: compute.IpAddresses.cidr('10.0.1.0/20')\n * });\n * ```\n *\n */\nclass Cidr implements IIpAddresses {\n  private readonly networkBuilder: NetworkBuilder;\n\n  constructor(private readonly cidrBlock: string) {\n    if (Token.isUnresolved(cidrBlock)) {\n      throw new Error(\n        \"'cidr' property must be a concrete CIDR string, got a Token (we need to parse it for automatic subdivision)\",\n      );\n    }\n\n    this.networkBuilder = new NetworkBuilder(this.cidrBlock);\n  }\n\n  /**\n   * Allocates Vpc CIDR. Called when creating a Vpc using IpAddresses.cidr.\n   */\n  allocateVpcCidr(): VpcIpamOptions {\n    return {\n      cidrBlock: this.networkBuilder.networkCidr.cidr,\n    };\n  }\n\n  /**\n   * Allocates Subnets Cidrs. Called by VPC when creating subnets.\n   */\n  allocateSubnetsCidr(input: AllocateCidrRequest): SubnetIpamOptions {\n    const allocatedSubnets: AllocatedSubnet[] = [];\n    const subnetsWithoutDefinedCidr: IRequestedSubnetInstance[] = [];\n    //default: Available IP space is evenly divided across subnets if no cidr is given.\n\n    input.requestedSubnets.forEach((requestedSubnet, index) => {\n      if (requestedSubnet.configuration.cidrMask === undefined) {\n        subnetsWithoutDefinedCidr.push({\n          index,\n          requestedSubnet,\n        });\n      } else {\n        allocatedSubnets.push({\n          cidr: this.networkBuilder.addSubnet(\n            requestedSubnet.configuration.cidrMask,\n          ),\n        });\n      }\n    });\n\n    const cidrMaskForRemaining = this.networkBuilder.maskForRemainingSubnets(\n      subnetsWithoutDefinedCidr.length,\n    );\n    subnetsWithoutDefinedCidr.forEach((subnet) => {\n      allocatedSubnets.splice(subnet.index, 0, {\n        cidr: this.networkBuilder.addSubnet(cidrMaskForRemaining),\n      });\n    });\n\n    return {\n      allocatedSubnets: allocatedSubnets,\n    };\n  }\n}\n\n/**\n * An abstract Provider of Ipv6Addresses.\n *\n * Note this is specific to the IPv6 CIDR.\n */\nexport class Ipv6Addresses {\n  /**\n   * Used for IPv6 address management with Amazon provided CIDRs.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  public static amazonProvided(): IIpv6Addresses {\n    return new AmazonProvided();\n  }\n\n  private constructor() {}\n}\n\n/**\n * Implementations for IPv6 address management.\n *\n * Note this is specific to the IPv6 CIDR.\n */\nexport interface IIpv6Addresses {\n  /**\n   * Whether the IPv6 CIDR is Amazon provided or not.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  amazonProvided: boolean;\n\n  /**\n   * Called by VPC to allocate IPv6 CIDR.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  allocateVpcIpv6Cidr(\n    input: AllocateVpcIpv6CidrRequest,\n  ): vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation;\n\n  /**\n   * Split IPv6 CIDR block up for subnets.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  createIpv6CidrBlocks(input: CreateIpv6CidrBlocksRequest): string[];\n\n  /**\n   * Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  allocateSubnetsIpv6Cidr(input: AllocateIpv6CidrRequest): SubnetIpamOptions;\n}\n\n/**\n * Implements integration with Amazon provided IPv6 CIDRs.\n *\n * Note this is specific to the IPv6 CIDR.\n */\nclass AmazonProvided implements IIpv6Addresses {\n  /**\n   * Whether the IPv6 CIDR is Amazon provided or not.\n   *\n   * equests an Amazon-provided IPv6 CIDR block with a /56 prefix length for the VPC.\n   * You cannot specify the range of IPv6 addresses, or the size of the CIDR block\n   */\n  amazonProvided: boolean;\n\n  constructor() {\n    this.amazonProvided = true;\n  }\n  /**\n   * Called by VPC to allocate IPv6 CIDR.\n   *\n   * Creates an Amazon provided CIDR block.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  allocateVpcIpv6Cidr(\n    input: AllocateVpcIpv6CidrRequest,\n  ): vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation {\n    //throw new Error(`vpcId not found, got ${(scope as any).vpcId}`);\n    return new vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation(\n      input.scope,\n      \"ipv6cidr\",\n      {\n        vpcId: input.vpcId,\n        assignGeneratedIpv6CidrBlock: this.amazonProvided,\n      },\n    );\n  }\n\n  /**\n   * Split IPv6 CIDR block up for subnets.\n   *\n   * Called by VPC when creating subnets with IPv6 enabled.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  createIpv6CidrBlocks(input: CreateIpv6CidrBlocksRequest): string[] {\n    let parentMask: number = input.parentMask ?? 56;\n    if (!Token.isUnresolved(input.ipv6SelectedCidr)) {\n      parentMask = parseInt(input.ipv6SelectedCidr.split(\"/\")[1], 10);\n      if (Number.isNaN(parentMask)) {\n        throw new Error(\n          `Parent CIDR must include a valid mask, got: '${input.ipv6SelectedCidr}'`,\n        );\n      }\n    }\n    const sizeMask = parseInt(input.sizeMask ?? \"64\"); // 128 - 64\n    const newbits = sizeMask - parentMask;\n\n    return Fn.cidrsubnets(\n      input.ipv6SelectedCidr,\n      Array.from({ length: input.subnetCount }, () => newbits),\n    );\n  }\n\n  /**\n   * Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.\n   *\n   * This function takes the list of allocated subnets,\n   * and copies the IPv4 CIDRs while also assigning the IPv6 CIDR.\n   *\n   * Note this is specific to the IPv6 CIDR.\n   */\n  allocateSubnetsIpv6Cidr(input: AllocateIpv6CidrRequest): SubnetIpamOptions {\n    const allocatedSubnets: AllocatedSubnet[] = [];\n\n    input.allocatedSubnets.forEach((allocated, i) => {\n      const allocatedIpv6: AllocatedSubnet = {\n        cidr: allocated.cidr,\n        ipv6Cidr: Fn.element(input.ipv6Cidrs, i),\n      };\n      allocatedSubnets.push(allocatedIpv6);\n    });\n\n    return {\n      allocatedSubnets: allocatedSubnets,\n    };\n  }\n}\n"]}

package/lib/aws/compute/ipam.d.ts

@@ -0,0 +1,309 @@
+import { vpcIpamPoolCidr as tfIpamPoolCidr } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase } from "../aws-construct";
+/**
+ * Represents the address family for IP addresses in an IPAM pool.
+ * IP_V4 - Represents the IPv4 address family.
+ * IP_V6 - Represents the IPv6 address family.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-addressfamily
+ */
+export declare enum AddressFamily {
+    /**
+     * Represents the IPv4 address family.
+     * Allowed under public and private pool.
+     */
+    IP_V4 = "ipv4",
+    /**
+     * Represents the IPv6 address family.
+     * Only allowed under public pool.
+     */
+    IP_V6 = "ipv6"
+}
+/**
+ * The IP address source for pools in the public scope.
+ * Only used for provisioning IP address CIDRs to pools in the public scope.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-publicipsource
+ */
+export declare enum IpamPoolPublicIpSource {
+    /**
+     * BYOIP Ipv6 to be registered under IPAM
+     */
+    BYOIP = "byoip",
+    /**
+     * Amazon Provided Ipv6 range
+     */
+    AMAZON = "amazon"
+}
+/**
+ * Limits which service in AWS that the pool can be used in
+ */
+export declare enum AwsServiceName {
+    /**
+     *  Allows users to use space for Elastic IP addresses and VPCs
+     */
+    EC2 = "ec2"
+}
+/**
+ * Options to create a new Ipam in the account
+ */
+export interface IpamProps {
+    /**
+     * The operating Regions for an IPAM.
+     * Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs
+     * For more information about operating Regions, see [Create an IPAM](https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html) in the *Amazon VPC IPAM User Guide* .
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-operatingregions
+     *
+     * @default - Stack.region if defined in the stack
+     */
+    readonly operatingRegion?: string[];
+    /**
+     * Name of IPAM that can be used for tagging resource
+     *
+     * @default - If no name provided, no tags will be added to the IPAM
+     */
+    readonly ipamName?: string;
+}
+/**
+ * Refers to two possible scope types under IPAM
+ */
+export declare enum IpamScopeType {
+    /**
+     * Default scopes created by IPAM
+     */
+    DEFAULT = "default",
+    /**
+     * Custom scope created using method
+     */
+    CUSTOM = "custom"
+}
+/**
+ * Options for configuring an IPAM pool.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html
+ */
+export interface PoolOptions {
+    /**
+     * addressFamily - The address family of the pool (ipv4 or ipv6).
+     */
+    readonly addressFamily: AddressFamily;
+    /**
+     * Information about the CIDRs provisioned to the pool.
+     *
+     * @default - No CIDRs are provisioned
+     */
+    readonly ipv4ProvisionedCidrs?: string[];
+    /**
+     * The locale (AWS Region) of the pool. Should be one of the IPAM operating region.
+     *  Only resources in the same Region as the locale of the pool can get IP address allocations from the pool.
+     * You can only allocate a CIDR for a VPC, for example, from an IPAM pool that shares a locale with the VPC’s Region.
+     * Note that once you choose a Locale for a pool, you cannot modify it. If you choose an AWS Region for locale that has not been configured as an operating Region for the IPAM, you'll get an error.
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-locale
+     *
+     * @default - Current operating region of IPAM
+     */
+    readonly locale?: string;
+    /**
+     * The IP address source for pools in the public scope.
+     * Only used for IPv6 address
+     * Only allowed values to this are 'byoip' or 'amazon'
+     *
+     * @default amazon
+     */
+    readonly publicIpSource?: IpamPoolPublicIpSource;
+    /**
+     * Limits which service in AWS that the pool can be used in.
+     *
+     * "ec2", for example, allows users to use space for Elastic IP addresses and VPCs.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-awsservice
+     *
+     * @default - required in case of an IPv6, throws an error if not provided.
+     */
+    readonly awsService?: AwsServiceName;
+    /**
+     * IPAM Pool resource name to be used for tagging
+     *
+     * @default - autogenerated by CDK if not provided
+     */
+    readonly ipamPoolName?: string;
+}
+/**
+ * Options to provision CIDRs to an IPAM pool.
+ * Used to create a new IpamPoolCidr
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html
+ */
+export interface IpamPoolCidrProvisioningOptions {
+    /**
+     * Ipv6 Netmask length for the CIDR
+     *
+     * @default - pool provisioned without netmask length, need cidr range in this case
+     */
+    readonly netmaskLength?: number;
+    /**
+     * Ipv6 CIDR block for the IPAM pool
+     *
+     * @default - pool provisioned without netmask length, need netmask length in this case
+     */
+    readonly cidr?: string;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface IpamPoolOutputs {
+    /**
+     * Pool ID to be passed to the VPC construct
+     * @attribute IpamPoolId
+     */
+    readonly ipamPoolId: string;
+}
+/**
+ * Definition used to add or create a new IPAM pool
+ */
+export interface IIpamPool extends IAwsConstruct {
+    /** strongly typed outputs */
+    readonly ipamPoolOutputs: IpamPoolOutputs;
+    /**
+     * Pool ID to be passed to the VPC construct
+     * @attribute IpamPoolId
+     */
+    readonly ipamPoolId: string;
+    /**
+     * Pool CIDR for IPv6 to be provisioned with Public IP source set to 'Amazon'
+     */
+    readonly ipamCidrs: tfIpamPoolCidr.VpcIpamPoolCidr[];
+    /**
+     * Pool CIDR for IPv4 to be provisioned using IPAM
+     * Required to check for subnet IP range is within the VPC range
+     */
+    readonly ipamIpv4Cidrs?: string[];
+    /**
+     * Function to associate a IPv6 address with IPAM pool
+     */
+    provisionCidr(id: string, options: IpamPoolCidrProvisioningOptions): tfIpamPoolCidr.VpcIpamPoolCidr;
+}
+/**
+ * Being used in IPAM class to add pools to default scope created by IPAM.
+ */
+export interface IpamScopeOptions {
+    /**
+     * IPAM scope name that will be used for tagging
+     *
+     * @default - no tags will be added to the scope
+     */
+    readonly ipamScopeName?: string;
+}
+/**
+ * Options for configuring an IP Address Manager (IPAM).
+ *
+ * For more information, see the {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html}.
+ */
+export interface IpamOptions {
+    /**
+     * CIDR Mask for Vpc
+     * Only required when using AWS Ipam
+     *
+     * @default - no netmask length for IPAM attached to VPC secondary address
+     */
+    readonly netmaskLength?: number;
+    /**
+     * Ipv4 or an Ipv6 IPAM pool
+     * Only required when using AWS Ipam
+     *
+     * @default - no pool attached to VPC secondary address
+     */
+    readonly ipamPool?: IIpamPool;
+    /**
+     * Required to set Secondary cidr block resource name
+     * in order to generate unique logical id for the resource.
+     */
+    readonly cidrBlockName: string;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface IpamScopeOutputs {
+    /**
+     * Scope ID to be passed to the VPC construct
+     * @attribute IpamScopeId
+     */
+    readonly ipamScopeId: string;
+}
+/**
+ * Interface for IpamScope Class
+ */
+export interface IIpamScopeBase {
+    /** strongly typed outputs */
+    readonly ipamScopeOutputs: IpamScopeOutputs;
+    /**
+     * Reference to the current scope of stack to be passed in order to create
+     * a new IPAM pool
+     */
+    readonly scope: Construct;
+    /**
+     * Default Scope ids created by the IPAM or a new Resource id
+     */
+    readonly scopeId: string;
+    /**
+     * Defines scope type can be either default or custom
+     */
+    readonly scopeType?: IpamScopeType;
+    /**
+     * Function to add a new pool to an IPAM scope
+     */
+    addPool(id: string, options: PoolOptions): IIpamPool;
+}
+export interface IpamOutputs {
+    /**
+     * Ipam ID to be passed to the VPC construct
+     * @attribute IpamId
+     */
+    readonly ipamId: string;
+}
+/**
+ * Creates new IPAM with default public and private scope
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam
+ * @resource aws_vpc_ipam
+ */
+export declare class Ipam extends AwsConstructBase {
+    get ipamOutputs(): IpamOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * Provides access to default public IPAM scope through add pool method.
+     * Usage: To add an Ipam Pool to a default public scope
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
+     */
+    readonly publicScope: IIpamScopeBase;
+    /**
+     * Provides access to default private IPAM scope through add pool method.
+     * Usage: To add an Ipam Pool to a default private scope
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
+     * */
+    readonly privateScope: IIpamScopeBase;
+    private readonly _ipam;
+    /**
+     * Access to Ipam resource id that can be used later to add a custom private scope to this IPAM
+     * @attribute IpamId
+     */
+    readonly ipamId: string;
+    /**
+     * List of operating regions for IPAM
+     */
+    readonly operatingRegions: string[];
+    /**
+     * List of scopes created under this IPAM
+     */
+    readonly scopes: IIpamScopeBase[];
+    /**
+     * IPAM name to be used for tagging
+     * @default no tag specified
+     * @attribute IpamName
+     */
+    readonly ipamName?: string;
+    constructor(scope: Construct, id: string, props?: IpamProps);
+    /**
+     * Function to add custom scope to an existing IPAM
+     * Custom scopes can only be private
+     */
+    addScope(scope: Construct, id: string, options: IpamScopeOptions): IIpamScopeBase;
+}