terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/instance.js

@@ -0,0 +1,262 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instance = 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/instance.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const require_imdsv2_aspect_1 = require("./aspects/require-imdsv2-aspect");
+// import { CloudFormationInit } from "./cfn-init";
+const connections_1 = require("./connections");
+const ebs_util_1 = require("./private/ebs-util");
+const security_group_1 = require("./security-group");
+const vpc_1 = require("./vpc");
+// import { md5hash } from "../../helpers-internal";
+const iam = require("../iam");
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * This represents a single EC2 instance
+ */
+class Instance extends aws_construct_1.AwsConstructBase {
+    get instanceOutputs() {
+        return {
+            instanceId: this.instanceId,
+        };
+    }
+    get outputs() {
+        return this.instanceOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.securityGroups = [];
+        // if (props.initOptions && !props.init) {
+        //   throw new Error("Setting 'initOptions' requires that 'init' is also set");
+        // }
+        if (props.keyName && props.keyPair) {
+            throw new Error("Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'");
+        }
+        // if credit specification is set, then the instance type must be burstable
+        if (props.creditSpecification && !props.instanceType.isBurstable()) {
+            throw new Error(`creditSpecification is supported only for T4g, T3a, T3, T2 instance type, got: ${props.instanceType.toString()}`);
+        }
+        if (props.securityGroup) {
+            this.securityGroup = props.securityGroup;
+        }
+        else {
+            this.securityGroup = new security_group_1.SecurityGroup(this, "InstanceSecurityGroup", {
+                vpc: props.vpc,
+                allowAllOutbound: props.allowAllOutbound !== false,
+                allowAllIpv6Outbound: props.allowAllIpv6Outbound,
+            });
+        }
+        this.connections = new connections_1.Connections({
+            securityGroups: [this.securityGroup],
+        });
+        this.securityGroups.push(this.securityGroup);
+        aws_tags_1.Tags.of(this).add(NAME_TAG, props.instanceName || this.node.path);
+        if (props.instanceProfile && props.role) {
+            throw new Error("You cannot provide both instanceProfile and role");
+        }
+        let iamInstanceProfile = undefined;
+        if (props.instanceProfile?.role) {
+            this.role = props.instanceProfile.role;
+            iamInstanceProfile = props.instanceProfile.instanceProfileName;
+        }
+        else {
+            this.role =
+                props.role ||
+                    new iam.Role(this, "InstanceRole", {
+                        assumedBy: new iam.ServicePrincipal("ec2.amazonaws.com"),
+                    });
+            const iamProfile = new provider_aws_1.iamInstanceProfile.IamInstanceProfile(this, "InstanceProfile", {
+                role: this.role.roleName,
+            });
+            iamInstanceProfile = iamProfile.id;
+        }
+        this.grantPrincipal = this.role;
+        if (props.ssmSessionPermissions) {
+            this.role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName(this, "AmazonSSMManagedInstanceCore", "AmazonSSMManagedInstanceCore"));
+        }
+        // use delayed evaluation
+        const imageConfig = props.machineImage.getImage(this);
+        this.userData = props.userData ?? imageConfig.userData;
+        const securityGroupsToken = cdktf_1.Lazy.listValue({
+            produce: () => this.securityGroups.map((sg) => sg.securityGroupId),
+        });
+        const { subnets, hasPublic } = props.vpc.selectSubnets(props.vpcSubnets);
+        let subnet;
+        if (props.availabilityZone) {
+            const selected = subnets.filter((sn) => sn.availabilityZone === props.availabilityZone);
+            if (selected.length === 1) {
+                subnet = selected[0];
+            }
+            else {
+                cdktf_1.Annotations.of(this).addError(`Need exactly 1 subnet to match AZ '${props.availabilityZone}', found ${selected.length}. Use a different availabilityZone.`);
+            }
+        }
+        else {
+            if (subnets.length > 0) {
+                subnet = subnets[0];
+            }
+            else {
+                cdktf_1.Annotations.of(this).addError(`Did not find any subnets matching '${JSON.stringify(props.vpcSubnets)}', please use a different selection.`);
+            }
+        }
+        if (!subnet) {
+            // We got here and we don't have a subnet because of validation errors.
+            // Invent one on the spot so the code below doesn't fail.
+            subnet = vpc_1.Subnet.fromSubnetAttributes(this, "DummySubnet", {
+                subnetId: "s-notfound",
+                availabilityZone: "az-notfound",
+            });
+        }
+        // network interfaces array is set to configure the primary network interface if associatePublicIpAddress is true or false
+        let networkInterfaces = undefined;
+        if (props.associatePublicIpAddress !== undefined) {
+            this.primaryNetworkInterface = new provider_aws_1.networkInterface.NetworkInterface(this, "NetworkInterface", {
+                subnetId: subnet.subnetId,
+                securityGroups: securityGroupsToken,
+                privateIps: props.privateIpAddress
+                    ? [props.privateIpAddress]
+                    : undefined,
+            });
+            // TODO: Use networkInterfaceAttachment instead?
+            // ref: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance#network-interfaces
+            networkInterfaces = [
+                {
+                    deviceIndex: 0,
+                    networkInterfaceId: this.primaryNetworkInterface.id,
+                },
+            ];
+        }
+        if (props.keyPair && !props.keyPair._isOsCompatible(imageConfig.osType)) {
+            throw new Error(`${props.keyPair.type} keys are not compatible with the chosen AMI`);
+        }
+        if (props.enclaveEnabled && props.hibernationEnabled) {
+            throw new Error("You can't set both `enclaveEnabled` and `hibernationEnabled` to true on the same instance");
+        }
+        if (props.ipv6AddressCount !== undefined &&
+            !cdktf_1.Token.isUnresolved(props.ipv6AddressCount) &&
+            (props.ipv6AddressCount < 0 || !Number.isInteger(props.ipv6AddressCount))) {
+            throw new Error(`\'ipv6AddressCount\' must be a non-negative integer, got: ${props.ipv6AddressCount}`);
+        }
+        if (props.ipv6AddressCount !== undefined &&
+            props.associatePublicIpAddress !== undefined) {
+            throw new Error("You can't set both 'ipv6AddressCount' and 'associatePublicIpAddress'");
+        }
+        // https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance#tag-guide
+        const volumeTags = props.propagateTagsToVolumeOnCreation
+            ? { [NAME_TAG]: props.instanceName || this.node.path }
+            : undefined;
+        // if network interfaces array is configured then subnetId, securityGroupIds,
+        // and privateIpAddress are configured on the network interface level and
+        // there is no need to configure them on the instance level
+        this.instance = new provider_aws_1.instance.Instance(this, "Resource", {
+            ami: imageConfig.imageId,
+            keyName: props.keyPair?.keyPairName ?? props?.keyName,
+            instanceType: props.instanceType.toString(),
+            subnetId: networkInterfaces ? undefined : subnet.subnetId,
+            securityGroups: networkInterfaces ? undefined : securityGroupsToken,
+            associatePublicIpAddress: props.associatePublicIpAddress,
+            networkInterface: networkInterfaces,
+            iamInstanceProfile,
+            userDataBase64: this.userData.render(this),
+            // unlike https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/instance.ts#L652
+            userDataReplaceOnChange: props.userDataCausesReplacement ?? true,
+            availabilityZone: subnet.availabilityZone,
+            sourceDestCheck: props.sourceDestCheck,
+            ebsBlockDevice: props.blockDevices !== undefined
+                ? (0, ebs_util_1.instanceEbsBlockDeviceMappings)(this, props.blockDevices)
+                : undefined,
+            rootBlockDevice: props.blockDevices !== undefined
+                ? (0, ebs_util_1.instanceRootBlockDeviceMapping)(this, props.blockDevices)
+                : undefined,
+            ephemeralBlockDevice: props.blockDevices !== undefined
+                ? (0, ebs_util_1.instanceEphemeralBlockDeviceMappings)(props.blockDevices)
+                : undefined,
+            privateIp: networkInterfaces ? undefined : props.privateIpAddress,
+            volumeTags,
+            monitoring: props.detailedMonitoring,
+            creditSpecification: props.creditSpecification
+                ? { cpuCredits: props.creditSpecification }
+                : undefined,
+            ebsOptimized: props.ebsOptimized,
+            disableApiTermination: props.disableApiTermination,
+            instanceInitiatedShutdownBehavior: props.instanceInitiatedShutdownBehavior,
+            placementGroup: props.placementGroup?.placementGroupName,
+            enclaveOptions: props.enclaveEnabled !== undefined
+                ? { enabled: props.enclaveEnabled }
+                : undefined,
+            hibernation: props.hibernationEnabled,
+            ipv6AddressCount: props.ipv6AddressCount,
+        });
+        this.instance.node.addDependency(this.role);
+        // if associatePublicIpAddress is true, then there must be a dependency on internet connectivity
+        if (props.associatePublicIpAddress !== undefined &&
+            props.associatePublicIpAddress) {
+            const internetConnected = props.vpc.selectSubnets(props.vpcSubnets).internetConnectivityEstablished;
+            this.instance.node.addDependency(internetConnected);
+        }
+        if (!hasPublic && props.associatePublicIpAddress) {
+            throw new Error("To set 'associatePublicIpAddress: true' you must select Public subnets (vpcSubnets: { subnetType: SubnetType.PUBLIC })");
+        }
+        this.osType = imageConfig.osType;
+        this.node.defaultChild = this.instance;
+        this.instanceId = this.instance.id;
+        this.instanceAvailabilityZone = this.instance.availabilityZone;
+        this.instancePrivateDnsName = this.instance.privateDns;
+        this.instancePrivateIp = this.instance.privateIp;
+        this.instancePublicDnsName = this.instance.publicDns;
+        this.instancePublicIp = this.instance.publicIp;
+        this.primaryNetworkInterfaceId = this.primaryNetworkInterface
+            ? this.primaryNetworkInterface.id
+            : this.instance.primaryNetworkInterfaceId;
+        // TODO: Add support for Cfn Signals
+        // // if both the resourceSignalTimeout and initOptions.timeout are set,
+        // // the timeout is summed together. This logic is done in applyCloudFormationInit.
+        // // This is because applyUpdatePolicies overwrites the timeout when both timeout fields are specified.
+        // this.applyUpdatePolicies(props);
+        // if (props.init) {
+        //   this.applyCloudFormationInit(props.init, props.initOptions);
+        // }
+        if (props.requireImdsv2) {
+            cdktf_1.Aspects.of(this).add(new require_imdsv2_aspect_1.InstanceRequireImdsv2Aspect());
+            // , {
+            //   priority: AspectPriority.MUTATING,
+            // });
+        }
+    }
+    /**
+     * Add the security group to the instance.
+     *
+     * @param securityGroup: The security group to add
+     */
+    addSecurityGroup(securityGroup) {
+        this.securityGroups.push(securityGroup);
+    }
+    /**
+     * Add command to the startup script of the instance.
+     * The command must be in the scripting language supported by the instance's OS (i.e. Linux/Windows).
+     */
+    addUserData(...commands) {
+        this.userData.addCommands(...commands);
+    }
+    /**
+     * Adds a statement to the IAM role assumed by the instance.
+     */
+    addToRolePolicy(statement) {
+        this.role.addToPrincipalPolicy(statement);
+    }
+}
+exports.Instance = Instance;
+_a = JSII_RTTI_SYMBOL_1;
+Instance[_a] = { fqn: "terraconstructs.aws.compute.Instance", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../src/aws/compute/instance.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/instance.ts\n\nimport {\n  instance,\n  iamInstanceProfile as tfInstanceProfile,\n  networkInterface as tfNetworkInterface,\n} from \"@cdktf/provider-aws\";\nimport {\n  Annotations,\n  Aspects,\n  // AspectPriority,\n  Lazy,\n  Token,\n} from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Duration } from \"../../duration\";\nimport { IAwsConstruct, AwsConstructBase } from \"../aws-construct\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\nimport { InstanceRequireImdsv2Aspect } from \"./aspects/require-imdsv2-aspect\";\n// import { CloudFormationInit } from \"./cfn-init\";\nimport { Connections, IConnectable } from \"./connections\";\nimport { InstanceType } from \"./instance-types\";\nimport { IKeyPair } from \"./key-pair\";\nimport {\n  CpuCredits,\n  InstanceInitiatedShutdownBehavior,\n} from \"./launch-template\";\nimport { IMachineImage, OperatingSystemType } from \"./machine-image\";\nimport { IPlacementGroup } from \"./placement-group\";\nimport {\n  instanceEbsBlockDeviceMappings,\n  instanceEphemeralBlockDeviceMappings,\n  instanceRootBlockDeviceMapping,\n} from \"./private/ebs-util\";\nimport { ISecurityGroup, SecurityGroup } from \"./security-group\";\nimport { UserData } from \"./user-data\";\nimport { BlockDevice } from \"./volume\";\nimport { IVpc, Subnet, SubnetSelection } from \"./vpc\";\n// import { md5hash } from \"../../helpers-internal\";\nimport * as iam from \"../iam\";\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface InstanceOutputs {\n  /**\n   * The instance's ID\n   *\n   * @attribute\n   */\n  readonly instanceId: string;\n}\n\nexport interface IInstance extends IAwsConstruct, IConnectable, iam.IGrantable {\n  /** Strongly typed outputs */\n  readonly instanceOutputs: InstanceOutputs;\n\n  /**\n   * The instance's ID\n   *\n   * @attribute\n   */\n  readonly instanceId: string;\n\n  /**\n   * The availability zone the instance was launched in\n   *\n   * @attribute\n   */\n  readonly instanceAvailabilityZone: string;\n\n  /**\n   * Private DNS name for this instance\n   * @attribute\n   */\n  readonly instancePrivateDnsName: string;\n\n  /**\n   * Private IP for this instance\n   *\n   * @attribute\n   */\n  readonly instancePrivateIp: string;\n\n  /**\n   * Publicly-routable DNS name for this instance.\n   *\n   * (May be an empty string if the instance does not have a public name).\n   *\n   * @attribute\n   */\n  readonly instancePublicDnsName: string;\n\n  /**\n   * Publicly-routable IP  address for this instance.\n   *\n   * (May be an empty string if the instance does not have a public IP).\n   *\n   * @attribute\n   */\n  readonly instancePublicIp: string;\n}\n\n/**\n * Properties of an EC2 Instance\n */\nexport interface InstanceProps {\n  /**\n   * Name of SSH keypair to grant access to instance\n   *\n   * @default - No SSH access will be possible.\n   * @deprecated - Use `keyPair` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair\n   */\n  readonly keyName?: string;\n\n  /**\n   * The SSH keypair to grant access to the instance.\n   *\n   * @default - No SSH access will be possible.\n   */\n  readonly keyPair?: IKeyPair;\n\n  /**\n   * Where to place the instance within the VPC\n   *\n   * @default - Private subnets.\n   */\n  readonly vpcSubnets?: SubnetSelection;\n\n  /**\n   * In which AZ to place the instance within the VPC\n   *\n   * @default - Random zone.\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * Whether the instance could initiate connections to anywhere by default.\n   * This property is only used when you do not provide a security group.\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean;\n\n  /**\n   * Whether the instance could initiate IPv6 connections to anywhere by default.\n   * This property is only used when you do not provide a security group.\n   *\n   * @default false\n   */\n  readonly allowAllIpv6Outbound?: boolean;\n\n  /**\n   * The length of time to wait for the resourceSignalCount\n   *\n   * The maximum value is 43200 (12 hours).\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly resourceSignalTimeout?: Duration;\n\n  /**\n   * VPC to launch the instance in.\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * Security Group to assign to this instance\n   *\n   * @default - create new security group\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * Type of instance to launch\n   */\n  readonly instanceType: InstanceType;\n\n  /**\n   * AMI to launch\n   */\n  readonly machineImage: IMachineImage;\n\n  /**\n   * Specific UserData to use\n   *\n   * The UserData may still be mutated after creation.\n   *\n   * Updates to this field will trigger a stop/start of the EC2 instance by default.\n   *\n   * If userDataCausesReplacement is set then updates to this field will trigger\n   * a destroy and recreate of the EC2 instance.\n   *\n   * @default - A UserData object appropriate for the MachineImage's\n   * Operating System is created.\n   */\n  readonly userData?: UserData;\n\n  /**\n   * Changes to the UserData force replacement\n   *\n   * Depending the EC2 instance type, changing UserData either\n   * restarts the instance or replaces the instance.\n   *\n   * - Instance store-backed instances are replaced.\n   * - EBS-backed instances are restarted.\n   *\n   * By default, restarting does not execute the new UserData so you\n   * will need a different mechanism to ensure the instance is restarted.\n   *\n   * default - true\n   */\n  readonly userDataCausesReplacement?: boolean;\n  // @default - true if `initOptions` is specified, false otherwise.\n\n  /**\n   * An IAM role to associate with the instance profile assigned to this Auto Scaling Group.\n   *\n   * The role must be assumable by the service principal `ec2.amazonaws.com`:\n   * Note: You can provide an instanceProfile or a role, but not both.\n   *\n   * @example\n   * const role = new iam.Role(this, 'MyRole', {\n   *   assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com')\n   * });\n   *\n   * @default - A role will automatically be created, it can be accessed via the `role` property\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The instance profile used to pass role information to EC2 instances.\n   *\n   * Note: You can provide an instanceProfile or a role, but not both.\n   *\n   * @default - No instance profile\n   */\n  readonly instanceProfile?: iam.IInstanceProfile;\n\n  /**\n   * The name of the instance\n   *\n   * @default - CDK generated name\n   */\n  readonly instanceName?: string;\n\n  /**\n   * Specifies whether to enable an instance launched in a VPC to perform NAT.\n   * This controls whether source/destination checking is enabled on the instance.\n   * A value of true means that checking is enabled, and false means that checking is disabled.\n   * The value must be false for the instance to perform NAT.\n   *\n   * @default true\n   */\n  readonly sourceDestCheck?: boolean;\n\n  /**\n   * Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.\n   *\n   * Each instance that is launched has an associated root device volume,\n   * either an Amazon EBS volume or an instance store volume.\n   * You can use block device mappings to specify additional EBS volumes or\n   * instance store volumes to attach to an instance when it is launched.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html\n   * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/instance#ebs-ephemeral-and-root-block-devices\n   *\n   * @default - Uses the block device mapping of the AMI\n   */\n  readonly blockDevices?: BlockDevice[];\n\n  /**\n   * Defines a private IP address to associate with an instance.\n   *\n   * Private IP should be available within the VPC that the instance is build within.\n   *\n   * @default - no association\n   */\n  readonly privateIpAddress?: string;\n\n  /**\n   * Propagate the EC2 instance tags to the EBS volumes.\n   *\n   * Do not propagate tags if you plan to manage block device tags outside\n   * the `aws_instance` configuration, such as using `tags` in an `aws_ebs_volume`\n   * resource attached via `aws_volume_attachment`.\n   *\n   * Doing so will result in resource cycling and inconsistent behavior.\n   *\n   * @default - false\n   */\n  readonly propagateTagsToVolumeOnCreation?: boolean;\n\n  // TODO: Implement Grid Init\n  // /**\n  //  * Apply the given CloudFormation Init configuration to the instance at startup\n  //  *\n  //  * @default - no CloudFormation init\n  //  */\n  // readonly init?: CloudFormationInit;\n  //\n  // /**\n  //  * Use the given options for applying CloudFormation Init\n  //  *\n  //  * Describes the configsets to use and the timeout to wait\n  //  *\n  //  * @default - default options\n  //  */\n  // readonly initOptions?: ApplyCloudFormationInitOptions;\n\n  /**\n   * Whether IMDSv2 should be required on this instance.\n   *\n   * @default - false\n   */\n  readonly requireImdsv2?: boolean;\n\n  /**\n   * Whether \"Detailed Monitoring\" is enabled for this instance\n   * Keep in mind that Detailed Monitoring results in extra charges\n   *\n   * @see http://aws.amazon.com/cloudwatch/pricing/\n   * @default - false\n   */\n  readonly detailedMonitoring?: boolean;\n\n  /**\n   * Add SSM session permissions to the instance role\n   *\n   * Setting this to `true` adds the necessary permissions to connect\n   * to the instance using SSM Session Manager. You can do this\n   * from the AWS Console.\n   *\n   * NOTE: Setting this flag to `true` may not be enough by itself.\n   * You must also use an AMI that comes with the SSM Agent, or install\n   * the SSM Agent yourself. See\n   * [Working with SSM Agent](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html)\n   * in the SSM Developer Guide.\n   *\n   * @default false\n   */\n  readonly ssmSessionPermissions?: boolean;\n\n  /**\n   * Whether to associate a public IP address to the primary network interface attached to this instance.\n   *\n   * You cannot specify this property and `ipv6AddressCount` at the same time.\n   *\n   * @default - public IP address is automatically assigned based on default behavior\n   */\n  readonly associatePublicIpAddress?: boolean;\n\n  /**\n   * Specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).\n   * The unlimited CPU credit option is not supported for T3 instances with a dedicated host.\n   *\n   * @default - T2 instances are standard, while T3, T4g, and T3a instances are unlimited.\n   */\n  readonly creditSpecification?: CpuCredits;\n\n  /**\n   * Indicates whether the instance is optimized for Amazon EBS I/O.\n   *\n   * This optimization provides dedicated throughput to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance.\n   * This optimization isn't available with all instance types.\n   * Additional usage charges apply when using an EBS-optimized instance.\n   *\n   * @default false\n   */\n  readonly ebsOptimized?: boolean;\n\n  /**\n   * If true, the instance will not be able to be terminated using the Amazon EC2 console, CLI, or API.\n   *\n   * To change this attribute after launch, use [ModifyInstanceAttribute](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html).\n   * Alternatively, if you set InstanceInitiatedShutdownBehavior to terminate, you can terminate the instance\n   * by running the shutdown command from the instance.\n   *\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-instance.html#cfn-ec2-instance-disableapitermination\n   *\n   * @default false\n   */\n  readonly disableApiTermination?: boolean;\n\n  /**\n   * Indicates whether an instance stops or terminates when you initiate shutdown from the instance\n   * (using the operating system command for system shutdown).\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior\n   *\n   * @default InstanceInitiatedShutdownBehavior.STOP\n   */\n  readonly instanceInitiatedShutdownBehavior?: InstanceInitiatedShutdownBehavior;\n\n  /**\n   * The placement group that you want to launch the instance into.\n   *\n   * @default - no placement group will be used for this instance.\n   */\n  readonly placementGroup?: IPlacementGroup;\n\n  /**\n   * Whether the instance is enabled for AWS Nitro Enclaves.\n   *\n   * Nitro Enclaves requires a Nitro-based virtualized parent instance with specific Intel/AMD with at least 4 vCPUs\n   * or Graviton with at least 2 vCPUs instance types and Linux/Windows host OS,\n   * while the enclave itself supports only Linux OS.\n   *\n   * You can't set both `enclaveEnabled` and `hibernationEnabled` to true on the same instance.\n   *\n   * @see https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave.html#nitro-enclave-reqs\n   *\n   * @default - false\n   */\n  readonly enclaveEnabled?: boolean;\n\n  /**\n   * Whether the instance is enabled for hibernation.\n   *\n   * You can't set both `enclaveEnabled` and `hibernationEnabled` to true on the same instance.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-hibernationoptions.html\n   *\n   * @default - false\n   */\n  readonly hibernationEnabled?: boolean;\n\n  /**\n   * The number of IPv6 addresses to associate with the primary network interface.\n   *\n   * Amazon EC2 chooses the IPv6 addresses from the range of your subnet.\n   *\n   * You cannot specify this property and `associatePublicIpAddress` at the same time.\n   *\n   * @default - For instances associated with an IPv6 subnet, use 1; otherwise, use 0.\n   */\n  readonly ipv6AddressCount?: number;\n}\n\n/**\n * This represents a single EC2 instance\n */\nexport class Instance extends AwsConstructBase implements IInstance {\n  public get instanceOutputs(): InstanceOutputs {\n    return {\n      instanceId: this.instanceId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.instanceOutputs;\n  }\n\n  /**\n   * The type of OS the instance is running.\n   */\n  public readonly osType: OperatingSystemType;\n\n  /**\n   * Allows specify security group connections for the instance.\n   */\n  public readonly connections: Connections;\n\n  /**\n   * The IAM role assumed by the instance.\n   */\n  public readonly role: iam.IRole;\n\n  /**\n   * The principal to grant permissions to\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * UserData for the instance\n   */\n  public readonly userData: UserData;\n\n  /**\n   * the underlying instance resource\n   */\n  public readonly instance: instance.Instance;\n\n  /**\n   * the primary network inteface (if applicable)\n   */\n  private readonly primaryNetworkInterface?: tfNetworkInterface.NetworkInterface;\n\n  /**\n   * the primary network interface id.\n   */\n  public readonly primaryNetworkInterfaceId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instanceId: string;\n  /**\n   * @attribute\n   */\n  public readonly instanceAvailabilityZone: string;\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateDnsName: string;\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateIp: string;\n  /**\n   * @attribute\n   */\n  public readonly instancePublicDnsName: string;\n  /**\n   * @attribute\n   */\n  public readonly instancePublicIp: string;\n\n  private readonly securityGroup: ISecurityGroup;\n  private readonly securityGroups: ISecurityGroup[] = [];\n\n  constructor(scope: Construct, id: string, props: InstanceProps) {\n    super(scope, id);\n\n    // if (props.initOptions && !props.init) {\n    //   throw new Error(\"Setting 'initOptions' requires that 'init' is also set\");\n    // }\n\n    if (props.keyName && props.keyPair) {\n      throw new Error(\n        \"Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'\",\n      );\n    }\n\n    // if credit specification is set, then the instance type must be burstable\n    if (props.creditSpecification && !props.instanceType.isBurstable()) {\n      throw new Error(\n        `creditSpecification is supported only for T4g, T3a, T3, T2 instance type, got: ${props.instanceType.toString()}`,\n      );\n    }\n\n    if (props.securityGroup) {\n      this.securityGroup = props.securityGroup;\n    } else {\n      this.securityGroup = new SecurityGroup(this, \"InstanceSecurityGroup\", {\n        vpc: props.vpc,\n        allowAllOutbound: props.allowAllOutbound !== false,\n        allowAllIpv6Outbound: props.allowAllIpv6Outbound,\n      });\n    }\n    this.connections = new Connections({\n      securityGroups: [this.securityGroup],\n    });\n    this.securityGroups.push(this.securityGroup);\n    Tags.of(this).add(NAME_TAG, props.instanceName || this.node.path);\n\n    if (props.instanceProfile && props.role) {\n      throw new Error(\"You cannot provide both instanceProfile and role\");\n    }\n\n    let iamInstanceProfile: string | undefined = undefined;\n    if (props.instanceProfile?.role) {\n      this.role = props.instanceProfile.role;\n      iamInstanceProfile = props.instanceProfile.instanceProfileName;\n    } else {\n      this.role =\n        props.role ||\n        new iam.Role(this, \"InstanceRole\", {\n          assumedBy: new iam.ServicePrincipal(\"ec2.amazonaws.com\"),\n        });\n\n      const iamProfile = new tfInstanceProfile.IamInstanceProfile(\n        this,\n        \"InstanceProfile\",\n        {\n          role: this.role.roleName,\n        },\n      );\n      iamInstanceProfile = iamProfile.id;\n    }\n\n    this.grantPrincipal = this.role;\n\n    if (props.ssmSessionPermissions) {\n      this.role.addManagedPolicy(\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          this,\n          \"AmazonSSMManagedInstanceCore\",\n          \"AmazonSSMManagedInstanceCore\",\n        ),\n      );\n    }\n\n    // use delayed evaluation\n    const imageConfig = props.machineImage.getImage(this);\n    this.userData = props.userData ?? imageConfig.userData;\n    const securityGroupsToken = Lazy.listValue({\n      produce: () => this.securityGroups.map((sg) => sg.securityGroupId),\n    });\n\n    const { subnets, hasPublic } = props.vpc.selectSubnets(props.vpcSubnets);\n    let subnet;\n    if (props.availabilityZone) {\n      const selected = subnets.filter(\n        (sn) => sn.availabilityZone === props.availabilityZone,\n      );\n      if (selected.length === 1) {\n        subnet = selected[0];\n      } else {\n        Annotations.of(this).addError(\n          `Need exactly 1 subnet to match AZ '${props.availabilityZone}', found ${selected.length}. Use a different availabilityZone.`,\n        );\n      }\n    } else {\n      if (subnets.length > 0) {\n        subnet = subnets[0];\n      } else {\n        Annotations.of(this).addError(\n          `Did not find any subnets matching '${JSON.stringify(props.vpcSubnets)}', please use a different selection.`,\n        );\n      }\n    }\n    if (!subnet) {\n      // We got here and we don't have a subnet because of validation errors.\n      // Invent one on the spot so the code below doesn't fail.\n      subnet = Subnet.fromSubnetAttributes(this, \"DummySubnet\", {\n        subnetId: \"s-notfound\",\n        availabilityZone: \"az-notfound\",\n      });\n    }\n\n    // network interfaces array is set to configure the primary network interface if associatePublicIpAddress is true or false\n    let networkInterfaces: instance.InstanceNetworkInterface[] | undefined =\n      undefined;\n    if (props.associatePublicIpAddress !== undefined) {\n      this.primaryNetworkInterface = new tfNetworkInterface.NetworkInterface(\n        this,\n        \"NetworkInterface\",\n        {\n          subnetId: subnet.subnetId,\n          securityGroups: securityGroupsToken,\n          privateIps: props.privateIpAddress\n            ? [props.privateIpAddress]\n            : undefined,\n        },\n      );\n      // TODO: Use networkInterfaceAttachment instead?\n      // ref: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance#network-interfaces\n      networkInterfaces = [\n        {\n          deviceIndex: 0,\n          networkInterfaceId: this.primaryNetworkInterface.id,\n        },\n      ];\n    }\n\n    if (props.keyPair && !props.keyPair._isOsCompatible(imageConfig.osType)) {\n      throw new Error(\n        `${props.keyPair.type} keys are not compatible with the chosen AMI`,\n      );\n    }\n\n    if (props.enclaveEnabled && props.hibernationEnabled) {\n      throw new Error(\n        \"You can't set both `enclaveEnabled` and `hibernationEnabled` to true on the same instance\",\n      );\n    }\n\n    if (\n      props.ipv6AddressCount !== undefined &&\n      !Token.isUnresolved(props.ipv6AddressCount) &&\n      (props.ipv6AddressCount < 0 || !Number.isInteger(props.ipv6AddressCount))\n    ) {\n      throw new Error(\n        `\\'ipv6AddressCount\\' must be a non-negative integer, got: ${props.ipv6AddressCount}`,\n      );\n    }\n\n    if (\n      props.ipv6AddressCount !== undefined &&\n      props.associatePublicIpAddress !== undefined\n    ) {\n      throw new Error(\n        \"You can't set both 'ipv6AddressCount' and 'associatePublicIpAddress'\",\n      );\n    }\n\n    // https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/instance#tag-guide\n    const volumeTags = props.propagateTagsToVolumeOnCreation\n      ? { [NAME_TAG]: props.instanceName || this.node.path }\n      : undefined;\n\n    // if network interfaces array is configured then subnetId, securityGroupIds,\n    // and privateIpAddress are configured on the network interface level and\n    // there is no need to configure them on the instance level\n    this.instance = new instance.Instance(this, \"Resource\", {\n      ami: imageConfig.imageId,\n      keyName: props.keyPair?.keyPairName ?? props?.keyName,\n      instanceType: props.instanceType.toString(),\n      subnetId: networkInterfaces ? undefined : subnet.subnetId,\n      securityGroups: networkInterfaces ? undefined : securityGroupsToken,\n      associatePublicIpAddress: props.associatePublicIpAddress,\n      networkInterface: networkInterfaces,\n      iamInstanceProfile,\n      userDataBase64: this.userData.render(this),\n      // unlike https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/instance.ts#L652\n      userDataReplaceOnChange: props.userDataCausesReplacement ?? true,\n      availabilityZone: subnet.availabilityZone,\n      sourceDestCheck: props.sourceDestCheck,\n      ebsBlockDevice:\n        props.blockDevices !== undefined\n          ? instanceEbsBlockDeviceMappings(this, props.blockDevices)\n          : undefined,\n      rootBlockDevice:\n        props.blockDevices !== undefined\n          ? instanceRootBlockDeviceMapping(this, props.blockDevices)\n          : undefined,\n      ephemeralBlockDevice:\n        props.blockDevices !== undefined\n          ? instanceEphemeralBlockDeviceMappings(props.blockDevices)\n          : undefined,\n      privateIp: networkInterfaces ? undefined : props.privateIpAddress,\n      volumeTags,\n      monitoring: props.detailedMonitoring,\n      creditSpecification: props.creditSpecification\n        ? { cpuCredits: props.creditSpecification }\n        : undefined,\n      ebsOptimized: props.ebsOptimized,\n      disableApiTermination: props.disableApiTermination,\n      instanceInitiatedShutdownBehavior:\n        props.instanceInitiatedShutdownBehavior,\n      placementGroup: props.placementGroup?.placementGroupName,\n      enclaveOptions:\n        props.enclaveEnabled !== undefined\n          ? { enabled: props.enclaveEnabled }\n          : undefined,\n      hibernation: props.hibernationEnabled,\n      ipv6AddressCount: props.ipv6AddressCount,\n    });\n    this.instance.node.addDependency(this.role);\n\n    // if associatePublicIpAddress is true, then there must be a dependency on internet connectivity\n    if (\n      props.associatePublicIpAddress !== undefined &&\n      props.associatePublicIpAddress\n    ) {\n      const internetConnected = props.vpc.selectSubnets(\n        props.vpcSubnets,\n      ).internetConnectivityEstablished;\n      this.instance.node.addDependency(internetConnected);\n    }\n\n    if (!hasPublic && props.associatePublicIpAddress) {\n      throw new Error(\n        \"To set 'associatePublicIpAddress: true' you must select Public subnets (vpcSubnets: { subnetType: SubnetType.PUBLIC })\",\n      );\n    }\n\n    this.osType = imageConfig.osType;\n    this.node.defaultChild = this.instance;\n\n    this.instanceId = this.instance.id;\n    this.instanceAvailabilityZone = this.instance.availabilityZone;\n    this.instancePrivateDnsName = this.instance.privateDns;\n    this.instancePrivateIp = this.instance.privateIp;\n    this.instancePublicDnsName = this.instance.publicDns;\n    this.instancePublicIp = this.instance.publicIp;\n    this.primaryNetworkInterfaceId = this.primaryNetworkInterface\n      ? this.primaryNetworkInterface.id\n      : this.instance.primaryNetworkInterfaceId;\n\n    // TODO: Add support for Cfn Signals\n    // // if both the resourceSignalTimeout and initOptions.timeout are set,\n    // // the timeout is summed together. This logic is done in applyCloudFormationInit.\n    // // This is because applyUpdatePolicies overwrites the timeout when both timeout fields are specified.\n    // this.applyUpdatePolicies(props);\n\n    // if (props.init) {\n    //   this.applyCloudFormationInit(props.init, props.initOptions);\n    // }\n\n    if (props.requireImdsv2) {\n      Aspects.of(this).add(new InstanceRequireImdsv2Aspect());\n      // , {\n      //   priority: AspectPriority.MUTATING,\n      // });\n    }\n  }\n\n  /**\n   * Add the security group to the instance.\n   *\n   * @param securityGroup: The security group to add\n   */\n  public addSecurityGroup(securityGroup: ISecurityGroup): void {\n    this.securityGroups.push(securityGroup);\n  }\n\n  /**\n   * Add command to the startup script of the instance.\n   * The command must be in the scripting language supported by the instance's OS (i.e. Linux/Windows).\n   */\n  public addUserData(...commands: string[]) {\n    this.userData.addCommands(...commands);\n  }\n\n  /**\n   * Adds a statement to the IAM role assumed by the instance.\n   */\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    this.role.addToPrincipalPolicy(statement);\n  }\n\n  // /**\n  //  * Use a CloudFormation Init configuration at instance startup\n  //  *\n  //  * This does the following:\n  //  *\n  //  * - Attaches the CloudFormation Init metadata to the Instance resource.\n  //  * - Add commands to the instance UserData to run `cfn-init` and `cfn-signal`.\n  //  * - Update the instance's CreationPolicy to wait for the `cfn-signal` commands.\n  //  */\n  // public applyCloudFormationInit(\n  //   init: CloudFormationInit,\n  //   options: ApplyCloudFormationInitOptions = {},\n  // ) {\n  //   init.attach(this.instance, {\n  //     platform: this.osType,\n  //     instanceRole: this.role,\n  //     userData: this.userData,\n  //     configSets: options.configSets,\n  //     embedFingerprint: options.embedFingerprint,\n  //     printLog: options.printLog,\n  //     ignoreFailures: options.ignoreFailures,\n  //     includeRole: options.includeRole,\n  //     includeUrl: options.includeUrl,\n  //   });\n  //   this.waitForResourceSignal(options.timeout ?? Duration.minutes(5));\n  // }\n\n  // /**\n  //  * Wait for a single additional resource signal\n  //  *\n  //  * Add 1 to the current ResourceSignal Count and add the given timeout to the current timeout.\n  //  *\n  //  * Use this to pause the CloudFormation deployment to wait for the instances\n  //  * in the AutoScalingGroup to report successful startup during\n  //  * creation and updates. The UserData script needs to invoke `cfn-signal`\n  //  * with a success or failure code after it is done setting up the instance.\n  //  */\n  // private waitForResourceSignal(timeout: Duration) {\n  //   const oldResourceSignal =\n  //     this.instance.cfnOptions.creationPolicy?.resourceSignal;\n  //   this.instance.cfnOptions.creationPolicy = {\n  //     ...this.instance.cfnOptions.creationPolicy,\n  //     resourceSignal: {\n  //       count: (oldResourceSignal?.count ?? 0) + 1,\n  //       timeout: (oldResourceSignal?.timeout\n  //         ? Duration.parse(oldResourceSignal?.timeout).plus(timeout)\n  //         : timeout\n  //       ).toIsoString(),\n  //     },\n  //   };\n  // }\n\n  // /**\n  //  * Apply CloudFormation update policies for the instance\n  //  */\n  // private applyUpdatePolicies(props: InstanceProps) {\n  //   if (props.resourceSignalTimeout !== undefined) {\n  //     this.instance.cfnOptions.creationPolicy = {\n  //       ...this.instance.cfnOptions.creationPolicy,\n  //       resourceSignal: {\n  //         ...this.instance.cfnOptions.creationPolicy?.resourceSignal,\n  //         timeout:\n  //           props.resourceSignalTimeout &&\n  //           props.resourceSignalTimeout.toIsoString(),\n  //       },\n  //     };\n  //   }\n  // }\n}\n\n// /**\n//  * Options for applying CloudFormation init to an instance or instance group\n//  */\n// export interface ApplyCloudFormationInitOptions {\n//   /**\n//    * ConfigSet to activate\n//    *\n//    * @default ['default']\n//    */\n//   readonly configSets?: string[];\n\n//   /**\n//    * Timeout waiting for the configuration to be applied\n//    *\n//    * @default Duration.minutes(5)\n//    */\n//   readonly timeout?: Duration;\n\n//   /**\n//    * Force instance replacement by embedding a config fingerprint\n//    *\n//    * If `true` (the default), a hash of the config will be embedded into the\n//    * UserData, so that if the config changes, the UserData changes.\n//    *\n//    * - If the EC2 instance is instance-store backed or\n//    *   `userDataCausesReplacement` is set, this will cause the instance to be\n//    *   replaced and the new configuration to be applied.\n//    * - If the instance is EBS-backed and `userDataCausesReplacement` is not\n//    *   set, the change of UserData will make the instance restart but not be\n//    *   replaced, and the configuration will not be applied automatically.\n//    *\n//    * If `false`, no hash will be embedded, and if the CloudFormation Init\n//    * config changes nothing will happen to the running instance. If a\n//    * config update introduces errors, you will not notice until after the\n//    * CloudFormation deployment successfully finishes and the next instance\n//    * fails to launch.\n//    *\n//    * @default true\n//    */\n//   readonly embedFingerprint?: boolean;\n\n//   /**\n//    * Print the results of running cfn-init to the Instance System Log\n//    *\n//    * By default, the output of running cfn-init is written to a log file\n//    * on the instance. Set this to `true` to print it to the System Log\n//    * (visible from the EC2 Console), `false` to not print it.\n//    *\n//    * (Be aware that the system log is refreshed at certain points in\n//    * time of the instance life cycle, and successful execution may\n//    * not always show up).\n//    *\n//    * @default true\n//    */\n//   readonly printLog?: boolean;\n\n//   /**\n//    * Don't fail the instance creation when cfn-init fails\n//    *\n//    * You can use this to prevent CloudFormation from rolling back when\n//    * instances fail to start up, to help in debugging.\n//    *\n//    * @default false\n//    */\n//   readonly ignoreFailures?: boolean;\n\n//   /**\n//    * Include --url argument when running cfn-init and cfn-signal commands\n//    *\n//    * This will be the cloudformation endpoint in the deployed region\n//    * e.g. https://cloudformation.us-east-1.amazonaws.com\n//    *\n//    * @default false\n//    */\n//   readonly includeUrl?: boolean;\n\n//   /**\n//    * Include --role argument when running cfn-init and cfn-signal commands\n//    *\n//    * This will be the IAM instance profile attached to the EC2 instance\n//    *\n//    * @default false\n//    */\n//   readonly includeRole?: boolean;\n// }\n"]}

package/lib/aws/compute/ip-addresses.d.ts

@@ -0,0 +1,249 @@
+import { vpcIpv6CidrBlockAssociation } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { SubnetConfiguration } from "./vpc";
+/**
+ * An abstract Provider of IpAddresses
+ *
+ * Note this is specific to the IPv4 CIDR.
+ */
+export declare 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: string): IIpAddresses;
+    /**
+     * 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: AwsIpamProps): IIpAddresses;
+    private constructor();
+}
+/**
+ * Implementations for ip address management.
+ *
+ * Note this is specific to the IPv4 CIDR.
+ */
+export interface IIpAddresses {
+    /**
+     * Called by the VPC to retrieve VPC options from the Ipam
+     *
+     * Don't call this directly, the VPC will call it automatically.
+     */
+    allocateVpcCidr(): VpcIpamOptions;
+    /**
+     * Called by the VPC to retrieve Subnet options from the Ipam
+     *
+     * Don't call this directly, the VPC will call it automatically.
+     */
+    allocateSubnetsCidr(input: AllocateCidrRequest): SubnetIpamOptions;
+}
+/**
+ * CIDR Allocated Vpc
+ */
+export interface VpcIpamOptions {
+    /**
+     * CIDR Block for Vpc
+     *
+     * @default - Only required when Ipam has concrete allocation available for static Vpc
+     */
+    readonly cidrBlock?: string;
+    /**
+     * CIDR Mask for Vpc
+     *
+     * @default - Only required when using AWS Ipam
+     */
+    readonly ipv4NetmaskLength?: number;
+    /**
+     * ipv4 IPAM Pool Id
+     *
+     * @default - Only required when using AWS Ipam
+     */
+    readonly ipv4IpamPoolId?: string;
+}
+/**
+ * Subnet requested for allocation
+ */
+export interface RequestedSubnet {
+    /**
+     * The availability zone for the subnet
+     */
+    readonly availabilityZone: string;
+    /**
+     * Specify configuration parameters for a single subnet group in a VPC
+     */
+    readonly configuration: SubnetConfiguration;
+    /**
+     * Id for the Subnet construct
+     */
+    readonly subnetConstructId: string;
+}
+/**
+ * Request for subnets CIDR to be allocated for a Vpc
+ */
+export interface AllocateCidrRequest {
+    /**
+     * The IPv4 CIDR block for this Vpc
+     */
+    readonly vpcCidr: string;
+    /**
+     * The Subnets to be allocated
+     */
+    readonly requestedSubnets: RequestedSubnet[];
+}
+/**
+ * Request for allocation of the VPC IPv6 CIDR.
+ */
+export interface AllocateVpcIpv6CidrRequest {
+    /**
+     * The VPC construct to attach to.
+     */
+    readonly scope: Construct;
+    /**
+     * The id of the VPC.
+     */
+    readonly vpcId: string;
+}
+/**
+ * Request for IPv6 CIDR block to be split up.
+ */
+export interface CreateIpv6CidrBlocksRequest {
+    /**
+     * The IPv6 CIDR block string representation.
+     */
+    readonly ipv6SelectedCidr: string;
+    /**
+     * The number of subnets to assign CIDRs to.
+     */
+    readonly subnetCount: number;
+    /**
+     * Size of the covered bits in the CIDR.
+     * @default - 128 - 64 = /64 CIDR.
+     */
+    readonly sizeMask?: string;
+    /**
+     * The parent mask of the CIDR.
+     *
+     * Valid values are from 44 to 60 in increments of 4.
+     *
+     * @default - 56
+     */
+    readonly parentMask?: number;
+}
+/**
+ * Request for subnet IPv6 CIDRs to be allocated for a VPC.
+ */
+export interface AllocateIpv6CidrRequest {
+    /**
+     * List of subnets allocated with IPv4 CIDRs
+     */
+    readonly allocatedSubnets: AllocatedSubnet[];
+    /**
+     * The IPv6 CIDRs to be allocated to the subnets
+     */
+    readonly ipv6Cidrs: string[];
+}
+/**
+ * CIDR Allocated Subnets
+ */
+export interface SubnetIpamOptions {
+    /**
+     * CIDR Allocations for Subnets
+     */
+    readonly allocatedSubnets: AllocatedSubnet[];
+}
+/**
+ * CIDR Allocated Subnet
+ */
+export interface AllocatedSubnet {
+    /**
+     * IPv4 CIDR Allocations for a Subnet.
+     *
+     * Note this is specific to the IPv4 CIDR.
+     */
+    readonly cidr: string;
+    /**
+     * IPv6 CIDR Allocations for a Subnet.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     *
+     * @default - no IPV6 CIDR
+     */
+    readonly ipv6Cidr?: string;
+}
+/**
+ * Configuration for AwsIpam
+ */
+export interface AwsIpamProps {
+    /**
+     * Netmask length for Vpc
+     */
+    readonly ipv4NetmaskLength: number;
+    /**
+     * Ipam Pool Id for ipv4 allocation
+     */
+    readonly ipv4IpamPoolId: string;
+    /**
+     * Default length for Subnet ipv4 Network mask
+     *
+     * Specify this option only if you do not specify all Subnets using SubnetConfiguration with a cidrMask
+     *
+     * @default - Default ipv4 Subnet Mask for subnets in Vpc
+     *
+     */
+    readonly defaultSubnetIpv4NetmaskLength?: number;
+}
+/**
+ * An abstract Provider of Ipv6Addresses.
+ *
+ * Note this is specific to the IPv6 CIDR.
+ */
+export declare class Ipv6Addresses {
+    /**
+     * Used for IPv6 address management with Amazon provided CIDRs.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    static amazonProvided(): IIpv6Addresses;
+    private constructor();
+}
+/**
+ * Implementations for IPv6 address management.
+ *
+ * Note this is specific to the IPv6 CIDR.
+ */
+export interface IIpv6Addresses {
+    /**
+     * Whether the IPv6 CIDR is Amazon provided or not.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    amazonProvided: boolean;
+    /**
+     * Called by VPC to allocate IPv6 CIDR.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    allocateVpcIpv6Cidr(input: AllocateVpcIpv6CidrRequest): vpcIpv6CidrBlockAssociation.VpcIpv6CidrBlockAssociation;
+    /**
+     * Split IPv6 CIDR block up for subnets.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    createIpv6CidrBlocks(input: CreateIpv6CidrBlocksRequest): string[];
+    /**
+     * Allocates Subnets IPv6 CIDRs. Called by VPC when creating subnets with IPv6 enabled.
+     *
+     * Note this is specific to the IPv6 CIDR.
+     */
+    allocateSubnetsIpv6Cidr(input: AllocateIpv6CidrRequest): SubnetIpamOptions;
+}