terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/launch-template.js

@@ -0,0 +1,468 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaunchTemplate = exports.LaunchTemplateSpecialVersions = exports.LaunchTemplateHttpTokens = exports.SpotRequestType = exports.SpotInstanceInterruption = exports.InstanceInitiatedShutdownBehavior = exports.CpuCredits = 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/launch-template.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const connections_1 = require("./connections");
+const ebs_util_1 = require("./private/ebs-util");
+const aws_construct_1 = require("../aws-construct");
+// TODO: Align with AWS CDK Tagging
+const aws_tags_1 = require("../aws-tags");
+/**
+ * Name tag constant
+ */
+const NAME_TAG = "Name";
+/**
+ * Provides the options for specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).
+ *
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-how-to.html
+ */
+// dev-note: This could be used in the Instance L2
+var CpuCredits;
+(function (CpuCredits) {
+    /**
+     * Standard bursting mode.
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-standard-mode.html
+     */
+    CpuCredits["STANDARD"] = "standard";
+    /**
+     * Unlimited bursting mode.
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode.html
+     */
+    CpuCredits["UNLIMITED"] = "unlimited";
+})(CpuCredits || (exports.CpuCredits = CpuCredits = {}));
+/**
+ * Provides the options for specifying the instance initiated shutdown behavior.
+ *
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior
+ */
+// dev-note: This could be used in the Instance L2
+var InstanceInitiatedShutdownBehavior;
+(function (InstanceInitiatedShutdownBehavior) {
+    /**
+     * The instance will stop when it initiates a shutdown.
+     */
+    InstanceInitiatedShutdownBehavior["STOP"] = "stop";
+    /**
+     * The instance will be terminated when it initiates a shutdown.
+     */
+    InstanceInitiatedShutdownBehavior["TERMINATE"] = "terminate";
+})(InstanceInitiatedShutdownBehavior || (exports.InstanceInitiatedShutdownBehavior = InstanceInitiatedShutdownBehavior = {}));
+/**
+ * Provides the options for the types of interruption for spot instances.
+ */
+// dev-note: This could be used in a SpotFleet L2 if one gets developed.
+var SpotInstanceInterruption;
+(function (SpotInstanceInterruption) {
+    /**
+     * The instance will stop when interrupted.
+     */
+    SpotInstanceInterruption["STOP"] = "stop";
+    /**
+     * The instance will be terminated when interrupted.
+     */
+    SpotInstanceInterruption["TERMINATE"] = "terminate";
+    /**
+     * The instance will hibernate when interrupted.
+     */
+    SpotInstanceInterruption["HIBERNATE"] = "hibernate";
+})(SpotInstanceInterruption || (exports.SpotInstanceInterruption = SpotInstanceInterruption = {}));
+/**
+ * The Spot Instance request type.
+ *
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html
+ */
+var SpotRequestType;
+(function (SpotRequestType) {
+    /**
+     * A one-time Spot Instance request remains active until Amazon EC2 launches the Spot Instance,
+     * the request expires, or you cancel the request. If the Spot price exceeds your maximum price
+     * or capacity is not available, your Spot Instance is terminated and the Spot Instance request
+     * is closed.
+     */
+    SpotRequestType["ONE_TIME"] = "one-time";
+    /**
+     * A persistent Spot Instance request remains active until it expires or you cancel it, even if
+     * the request is fulfilled. If the Spot price exceeds your maximum price or capacity is not available,
+     * your Spot Instance is interrupted. After your instance is interrupted, when your maximum price exceeds
+     * the Spot price or capacity becomes available again, the Spot Instance is started if stopped or resumed
+     * if hibernated.
+     */
+    SpotRequestType["PERSISTENT"] = "persistent";
+})(SpotRequestType || (exports.SpotRequestType = SpotRequestType = {}));
+/**
+ * The state of token usage for your instance metadata requests.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httptokens
+ */
+var LaunchTemplateHttpTokens;
+(function (LaunchTemplateHttpTokens) {
+    /**
+     * If the state is optional, you can choose to retrieve instance metadata with or without a signed token header on your request.
+     */
+    LaunchTemplateHttpTokens["OPTIONAL"] = "optional";
+    /**
+     * If the state is required, you must send a signed token header with any instance metadata retrieval requests. In this state,
+     * retrieving the IAM role credentials always returns the version 2.0 credentials; the version 1.0 credentials are not available.
+     */
+    LaunchTemplateHttpTokens["REQUIRED"] = "required";
+})(LaunchTemplateHttpTokens || (exports.LaunchTemplateHttpTokens = LaunchTemplateHttpTokens = {}));
+/**
+ * A class that provides convenient access to special version tokens for LaunchTemplate
+ * versions.
+ */
+class LaunchTemplateSpecialVersions {
+}
+exports.LaunchTemplateSpecialVersions = LaunchTemplateSpecialVersions;
+_a = JSII_RTTI_SYMBOL_1;
+LaunchTemplateSpecialVersions[_a] = { fqn: "terraconstructs.aws.compute.LaunchTemplateSpecialVersions", version: "0.0.12" };
+/**
+ * The special value that denotes that users of a Launch Template should
+ * reference the LATEST version of the template.
+ */
+LaunchTemplateSpecialVersions.LATEST_VERSION = "$Latest";
+/**
+ * The special value that denotes that users of a Launch Template should
+ * reference the DEFAULT version of the template.
+ */
+LaunchTemplateSpecialVersions.DEFAULT_VERSION = "$Default";
+/**
+ * This represents an EC2 LaunchTemplate.
+ *
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html
+ */
+class LaunchTemplate extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing LaunchTemplate.
+     */
+    static fromLaunchTemplateAttributes(scope, id, attrs) {
+        const haveId = Boolean(attrs.launchTemplateId);
+        const haveName = Boolean(attrs.launchTemplateName);
+        if (haveId == haveName) {
+            throw new Error("LaunchTemplate.fromLaunchTemplateAttributes() requires exactly one of launchTemplateId or launchTemplateName be provided.");
+        }
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.versionNumber = attrs.versionNumber ?? LaunchTemplateSpecialVersions.DEFAULT_VERSION;
+                this.launchTemplateId = attrs.launchTemplateId;
+                this.launchTemplateName = attrs.launchTemplateName;
+            }
+            get launchTemplateOutputs() {
+                return {
+                    versionNumber: this.versionNumber,
+                    launchTemplateId: this.launchTemplateId,
+                    launchTemplateName: this.launchTemplateName,
+                };
+            }
+            get outputs() {
+                return this.launchTemplateOutputs;
+            }
+        }
+        return new Import(scope, id);
+    }
+    // ============================================
+    //   Members for ILaunchTemplate/ITerraConstruct interface
+    get launchTemplateOutputs() {
+        return {
+            versionNumber: this.versionNumber,
+            launchTemplateId: this.launchTemplateId,
+            launchTemplateName: this.launchTemplateName,
+        };
+    }
+    get outputs() {
+        return this.launchTemplateOutputs;
+    }
+    set tags(value) {
+        this._tags = value;
+    }
+    get tags() {
+        return cdktf_1.Token.asStringMap(cdktf_1.Lazy.anyValue({
+            produce: () => this._tags ?? undefined,
+        }));
+    }
+    // Temporarily expose input value. Use with caution.
+    get tagsInput() {
+        return this._tags;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        // /**
+        //  * TagManager for tagging support.
+        //  */
+        // protected readonly tags: TagManager;
+        // isTaggableConstruct required properties
+        this._tags = undefined;
+        // Basic validation of the provided spot block duration
+        const spotDuration = props?.spotOptions?.blockDuration?.toHours({
+            integral: true,
+        });
+        if (spotDuration !== undefined && (spotDuration < 1 || spotDuration > 6)) {
+            // See: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances
+            cdktf_1.Annotations.of(this).addError("Spot block duration must be exactly 1, 2, 3, 4, 5, or 6 hours.");
+        }
+        // Basic validation of the provided httpPutResponseHopLimit
+        if (props.httpPutResponseHopLimit !== undefined &&
+            (props.httpPutResponseHopLimit < 1 || props.httpPutResponseHopLimit > 64)) {
+            // See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpputresponsehoplimit
+            cdktf_1.Annotations.of(this).addError("HttpPutResponseHopLimit must between 1 and 64");
+        }
+        if (props.instanceProfile && props.role) {
+            throw new Error("You cannot provide both an instanceProfile and a role");
+        }
+        if (props.keyName && props.keyPair) {
+            throw new Error("Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'");
+        }
+        // use provided instance profile or create one if a role was provided
+        let iamProfileArn = undefined;
+        if (props.instanceProfile) {
+            this.role = props.instanceProfile.role;
+            iamProfileArn = props.instanceProfile.instanceProfileArn;
+        }
+        else if (props.role) {
+            this.role = props.role;
+            const iamProfile = new provider_aws_1.iamInstanceProfile.IamInstanceProfile(this, "Profile", {
+                role: this.role.roleName,
+            });
+            iamProfileArn = iamProfile.arn;
+        }
+        this._grantPrincipal = this.role;
+        if (props.securityGroup) {
+            this._connections = new connections_1.Connections({
+                securityGroups: [props.securityGroup],
+            });
+        }
+        const securityGroupsToken = cdktf_1.Lazy.listValue({
+            produce: () => {
+                if (this._connections && this._connections.securityGroups.length > 0) {
+                    return this._connections.securityGroups.map((sg) => sg.securityGroupId);
+                }
+                return undefined;
+            },
+        });
+        const imageConfig = props.machineImage?.getImage(this);
+        if (imageConfig) {
+            this.osType = imageConfig.osType;
+            this.imageId = imageConfig.imageId;
+        }
+        if (this.osType &&
+            props.keyPair &&
+            !props.keyPair._isOsCompatible(this.osType)) {
+            throw new Error(`${props.keyPair.type} keys are not compatible with the chosen AMI`);
+        }
+        // priority: prop.userData -> userData from machineImage -> undefined
+        this.userData = props.userData ?? imageConfig?.userData;
+        this.instanceType = props.instanceType;
+        let marketOptions = undefined;
+        if (props?.spotOptions) {
+            marketOptions = {
+                marketType: "spot",
+                spotOptions: {
+                    blockDurationMinutes: spotDuration !== undefined ? spotDuration * 60 : undefined,
+                    instanceInterruptionBehavior: props.spotOptions.interruptionBehavior,
+                    maxPrice: props.spotOptions.maxPrice?.toString(),
+                    spotInstanceType: props.spotOptions.requestType,
+                    validUntil: props.spotOptions.validUntil?.date.toUTCString(),
+                },
+            };
+            // Remove SpotOptions if there are none.
+            if (Object.keys(marketOptions.spotOptions).filter((k) => marketOptions.spotOptions[k]).length == 0) {
+                marketOptions.spotOptions = undefined;
+            }
+        }
+        // this.tags = new TagManager(
+        //   TagType.KEY_VALUE,
+        //   tfLaunchTemplate.LaunchTemplate.tfResourceType,
+        // );
+        const tagsToken = cdktf_1.Lazy.anyValue({
+            produce: () => {
+                if (this._tags) {
+                    return [
+                        {
+                            resourceType: "instance",
+                            tags: this._tags,
+                        },
+                        {
+                            resourceType: "volume",
+                            tags: this._tags,
+                        },
+                        {
+                            resourceType: "launch-template",
+                            tags: this._tags,
+                        },
+                    ].map(provider_aws_1.launchTemplate.launchTemplateTagSpecificationsToTerraform);
+                }
+                return undefined;
+            },
+        });
+        const networkInterfaces = props.associatePublicIpAddress !== undefined
+            ? [
+                {
+                    deviceIndex: 0,
+                    associatePublicIpAddress: props.associatePublicIpAddress?.toString(),
+                    securityGroups: securityGroupsToken,
+                },
+            ]
+            : undefined;
+        if (props.versionDescription &&
+            !cdktf_1.Token.isUnresolved(props.versionDescription) &&
+            props.versionDescription.length > 255) {
+            throw new Error(`versionDescription must be less than or equal to 255 characters, got ${props.versionDescription.length}`);
+        }
+        this.resource = new provider_aws_1.launchTemplate.LaunchTemplate(this, "Resource", {
+            name: props?.launchTemplateName,
+            description: props?.versionDescription,
+            blockDeviceMappings: props?.blockDevices !== undefined
+                ? (0, ebs_util_1.launchTemplateBlockDeviceMappings)(this, props.blockDevices)
+                : undefined,
+            creditSpecification: props?.cpuCredits !== undefined
+                ? {
+                    cpuCredits: props.cpuCredits,
+                }
+                : undefined,
+            disableApiTermination: props?.disableApiTermination,
+            ebsOptimized: props?.ebsOptimized?.toString(),
+            enclaveOptions: props?.nitroEnclaveEnabled !== undefined
+                ? {
+                    enabled: props.nitroEnclaveEnabled,
+                }
+                : undefined,
+            hibernationOptions: props?.hibernationConfigured !== undefined
+                ? {
+                    configured: props.hibernationConfigured,
+                }
+                : undefined,
+            iamInstanceProfile: iamProfileArn !== undefined ? { arn: iamProfileArn } : undefined,
+            imageId: imageConfig?.imageId,
+            instanceType: props?.instanceType?.toString(),
+            instanceInitiatedShutdownBehavior: props?.instanceInitiatedShutdownBehavior,
+            instanceMarketOptions: marketOptions,
+            keyName: props.keyPair?.keyPairName ?? props?.keyName,
+            monitoring: props?.detailedMonitoring !== undefined
+                ? {
+                    enabled: props.detailedMonitoring,
+                }
+                : undefined,
+            vpcSecurityGroupIds: networkInterfaces ? undefined : securityGroupsToken,
+            tagSpecifications: tagsToken,
+            userData: this.userData?.render(this),
+            metadataOptions: this.renderMetadataOptions(props),
+            networkInterfaces,
+            // Fields not yet implemented:
+            // ==========================
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-capacityreservationspecification.html
+            // Will require creating an L2 for AWS::EC2::CapacityReservation
+            // capacityReservationSpecification: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-cpuoptions.html
+            // cpuOptions: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-elasticgpuspecification.html
+            // elasticGpuSpecifications: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-elasticinferenceaccelerators
+            // elasticInferenceAccelerators: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-kernelid
+            // kernelId: undefined,
+            // ramDiskId: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-licensespecifications
+            // Also not implemented in Instance L2
+            // licenseSpecifications: undefined,
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-tagspecifications
+            // Should be implemented via the Tagging aspect in CDK core. Complication will be that this tagging interface is very unique to LaunchTemplates.
+            // tagSpecification: undefined
+            // TODO: use IPlacementGroup in LuanchTemplate
+            // placement: undefined,
+        });
+        if (this.role) {
+            this.resource.node.addDependency(this.role);
+        }
+        else if (props.instanceProfile?.role) {
+            this.resource.node.addDependency(props.instanceProfile.role);
+        }
+        aws_tags_1.Tags.of(this).add(NAME_TAG, this.node.path);
+        this.defaultVersionNumber = this.resource.defaultVersion.toString(); // should be Token.asString()?
+        this.latestVersionNumber = this.resource.latestVersion.toString(); // should be Token.asString()?
+        this.launchTemplateId = this.resource.id;
+        this.versionNumber = this.resource.latestVersion.toString();
+    }
+    renderMetadataOptions(props) {
+        let requireMetadataOptions = false;
+        // if requireImdsv2 is true, httpTokens must be required.
+        if (props.requireImdsv2 === true &&
+            props.httpTokens === LaunchTemplateHttpTokens.OPTIONAL) {
+            cdktf_1.Annotations.of(this).addError("httpTokens must be required when requireImdsv2 is true");
+        }
+        if (props.httpEndpoint !== undefined ||
+            props.httpProtocolIpv6 !== undefined ||
+            props.httpPutResponseHopLimit !== undefined ||
+            props.httpTokens !== undefined ||
+            props.instanceMetadataTags !== undefined ||
+            props.requireImdsv2 === true) {
+            requireMetadataOptions = true;
+        }
+        if (requireMetadataOptions) {
+            return {
+                httpEndpoint: props.httpEndpoint === true
+                    ? "enabled"
+                    : props.httpEndpoint === false
+                        ? "disabled"
+                        : undefined,
+                httpProtocolIpv6: props.httpProtocolIpv6 === true
+                    ? "enabled"
+                    : props.httpProtocolIpv6 === false
+                        ? "disabled"
+                        : undefined,
+                httpPutResponseHopLimit: props.httpPutResponseHopLimit,
+                httpTokens: props.requireImdsv2 === true
+                    ? LaunchTemplateHttpTokens.REQUIRED
+                    : props.httpTokens,
+                instanceMetadataTags: props.instanceMetadataTags === true
+                    ? "enabled"
+                    : props.instanceMetadataTags === false
+                        ? "disabled"
+                        : undefined,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Add the security group to the instance.
+     *
+     * @param securityGroup: The security group to add
+     */
+    addSecurityGroup(securityGroup) {
+        if (!this._connections) {
+            throw new Error("LaunchTemplate can only be added a securityGroup if another securityGroup is initialized in the constructor.");
+        }
+        this._connections.addSecurityGroup(securityGroup);
+    }
+    /**
+     * Allows specifying security group connections for the instance.
+     *
+     * @note Only available if you provide a securityGroup when constructing the LaunchTemplate.
+     */
+    get connections() {
+        if (!this._connections) {
+            throw new Error("LaunchTemplate can only be used as IConnectable if a securityGroup is provided when constructing it.");
+        }
+        return this._connections;
+    }
+    /**
+     * Principal to grant permissions to.
+     *
+     * @note Only available if you provide a role when constructing the LaunchTemplate.
+     */
+    get grantPrincipal() {
+        if (!this._grantPrincipal) {
+            throw new Error("LaunchTemplate can only be used as IGrantable if a role is provided when constructing it.");
+        }
+        return this._grantPrincipal;
+    }
+}
+exports.LaunchTemplate = LaunchTemplate;
+_b = JSII_RTTI_SYMBOL_1;
+LaunchTemplate[_b] = { fqn: "terraconstructs.aws.compute.LaunchTemplate", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"launch-template.js","sourceRoot":"","sources":["../../../src/aws/compute/launch-template.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/launch-template.ts\n\nimport {\n  launchTemplate as tfLaunchTemplate,\n  iamInstanceProfile as tfIamInstanceProfile,\n} from \"@cdktf/provider-aws\";\nimport { Annotations, Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Connections, IConnectable } from \"./connections\";\nimport { InstanceType } from \"./instance-types\";\nimport { IKeyPair } from \"./key-pair\";\nimport {\n  IMachineImage,\n  MachineImageConfig,\n  OperatingSystemType,\n} from \"./machine-image\";\nimport { launchTemplateBlockDeviceMappings } from \"./private/ebs-util\";\nimport { ISecurityGroup } from \"./security-group\";\nimport { UserData } from \"./user-data\";\nimport { BlockDevice } from \"./volume\";\nimport { Duration } from \"../../duration\";\nimport { Expiration } from \"../../expiration\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  // TagType\n} from \"../aws-construct\";\n// TODO: Align with AWS CDK Tagging\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\n// import { TagManager } from \"../tag-manager\";\nimport * as iam from \"../iam\";\n\n/**\n * Name tag constant\n */\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Provides the options for specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).\n *\n * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-how-to.html\n */\n// dev-note: This could be used in the Instance L2\nexport enum CpuCredits {\n  /**\n   * Standard bursting mode.\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-standard-mode.html\n   */\n  STANDARD = \"standard\",\n\n  /**\n   * Unlimited bursting mode.\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances-unlimited-mode.html\n   */\n  UNLIMITED = \"unlimited\",\n}\n\n/**\n * Provides the options for specifying the instance initiated shutdown behavior.\n *\n * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior\n */\n// dev-note: This could be used in the Instance L2\nexport enum InstanceInitiatedShutdownBehavior {\n  /**\n   * The instance will stop when it initiates a shutdown.\n   */\n  STOP = \"stop\",\n\n  /**\n   * The instance will be terminated when it initiates a shutdown.\n   */\n  TERMINATE = \"terminate\",\n}\n\nexport interface LaunchTemplateOutputs {\n  /**\n   * The version number of this launch template to use\n   *\n   * @attribute\n   */\n  readonly versionNumber: string;\n\n  /**\n   * The identifier of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` will be set.\n   *\n   * @attribute\n   */\n  readonly launchTemplateId?: string;\n\n  /**\n   * The name of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` will be set.\n   *\n   * @attribute\n   */\n  readonly launchTemplateName?: string;\n}\n\n/**\n * Interface for LaunchTemplate-like objects.\n */\nexport interface ILaunchTemplate extends IAwsConstruct {\n  /** strongly typed outputs */\n  readonly launchTemplateOutputs: LaunchTemplateOutputs;\n\n  /**\n   * The version number of this launch template to use\n   *\n   * @attribute\n   */\n  readonly versionNumber: string;\n\n  /**\n   * The identifier of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` will be set.\n   *\n   * @attribute\n   */\n  readonly launchTemplateId?: string;\n\n  /**\n   * The name of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` will be set.\n   *\n   * @attribute\n   */\n  readonly launchTemplateName?: string;\n}\n\n/**\n * Provides the options for the types of interruption for spot instances.\n */\n// dev-note: This could be used in a SpotFleet L2 if one gets developed.\nexport enum SpotInstanceInterruption {\n  /**\n   * The instance will stop when interrupted.\n   */\n  STOP = \"stop\",\n\n  /**\n   * The instance will be terminated when interrupted.\n   */\n  TERMINATE = \"terminate\",\n\n  /**\n   * The instance will hibernate when interrupted.\n   */\n  HIBERNATE = \"hibernate\",\n}\n\n/**\n * The Spot Instance request type.\n *\n * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html\n */\nexport enum SpotRequestType {\n  /**\n   * A one-time Spot Instance request remains active until Amazon EC2 launches the Spot Instance,\n   * the request expires, or you cancel the request. If the Spot price exceeds your maximum price\n   * or capacity is not available, your Spot Instance is terminated and the Spot Instance request\n   * is closed.\n   */\n  ONE_TIME = \"one-time\",\n\n  /**\n   * A persistent Spot Instance request remains active until it expires or you cancel it, even if\n   * the request is fulfilled. If the Spot price exceeds your maximum price or capacity is not available,\n   * your Spot Instance is interrupted. After your instance is interrupted, when your maximum price exceeds\n   * the Spot price or capacity becomes available again, the Spot Instance is started if stopped or resumed\n   * if hibernated.\n   */\n  PERSISTENT = \"persistent\",\n}\n\n/**\n * Interface for the Spot market instance options provided in a LaunchTemplate.\n */\nexport interface LaunchTemplateSpotOptions {\n  /**\n   * Spot Instances with a defined duration (also known as Spot blocks) are designed not to be interrupted and will run continuously for the duration you select.\n   * You can use a duration of 1, 2, 3, 4, 5, or 6 hours.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances\n   *\n   * @default Requested spot instances do not have a pre-defined duration.\n   */\n  readonly blockDuration?: Duration;\n\n  /**\n   * The behavior when a Spot Instance is interrupted.\n   *\n   * @default Spot instances will terminate when interrupted.\n   */\n  readonly interruptionBehavior?: SpotInstanceInterruption;\n\n  /**\n   * Maximum hourly price you're willing to pay for each Spot instance. The value is given\n   * in dollars. ex: 0.01 for 1 cent per hour, or 0.001 for one-tenth of a cent per hour.\n   *\n   * @default Maximum hourly price will default to the on-demand price for the instance type.\n   */\n  readonly maxPrice?: number;\n\n  /**\n   * The Spot Instance request type.\n   *\n   * If you are using Spot Instances with an Auto Scaling group, use one-time requests, as the\n   * Amazon EC2 Auto Scaling service handles requesting new Spot Instances whenever the group is\n   * below its desired capacity.\n   *\n   * @default One-time spot request.\n   */\n  readonly requestType?: SpotRequestType;\n\n  /**\n   * The end date of the request. For a one-time request, the request remains active until all instances\n   * launch, the request is canceled, or this date is reached. If the request is persistent, it remains\n   * active until it is canceled or this date and time is reached.\n   *\n   * @default The default end date is 7 days from the current date.\n   */\n  readonly validUntil?: Expiration;\n}\n\n/**\n * The state of token usage for your instance metadata requests.\n *\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httptokens\n */\nexport enum LaunchTemplateHttpTokens {\n  /**\n   * If the state is optional, you can choose to retrieve instance metadata with or without a signed token header on your request.\n   */\n  OPTIONAL = \"optional\",\n  /**\n   * If the state is required, you must send a signed token header with any instance metadata retrieval requests. In this state,\n   * retrieving the IAM role credentials always returns the version 2.0 credentials; the version 1.0 credentials are not available.\n   */\n  REQUIRED = \"required\",\n}\n\n/**\n * Properties of a LaunchTemplate.\n */\nexport interface LaunchTemplateProps {\n  /**\n   * Name for this launch template.\n   *\n   * @default Automatically generated name\n   */\n  readonly launchTemplateName?: string;\n\n  /**\n   * A description for the first version of the launch template.\n   *\n   * The version description must be maximum 255 characters long.\n   *\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-launchtemplate.html#cfn-ec2-launchtemplate-versiondescription\n   *\n   * @default - No description\n   */\n  readonly versionDescription?: string;\n\n  /**\n   * Type of instance to launch.\n   *\n   * @default - This Launch Template does not specify a default Instance Type.\n   */\n  readonly instanceType?: InstanceType;\n\n  /**\n   * The AMI that will be used by instances.\n   *\n   * @default - This Launch Template does not specify a default AMI.\n   */\n  readonly machineImage?: IMachineImage;\n\n  /**\n   * The AMI that will be used by instances.\n   *\n   * @default - This Launch Template creates a UserData based on the type of provided\n   * machineImage; no UserData is created if a machineImage is not provided\n   */\n  readonly userData?: UserData;\n\n  /**\n   * An IAM role to associate with the instance profile that is used by instances.\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 - No new role is created.\n   */\n  readonly role?: iam.IRole;\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   *\n   * @default - Uses the block device mapping of the AMI\n   */\n  readonly blockDevices?: BlockDevice[];\n\n  /**\n   * CPU credit type for burstable EC2 instance types.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html\n   *\n   * @default - No credit type is specified in the Launch Template.\n   */\n  readonly cpuCredits?: CpuCredits;\n\n  /**\n   * If you set this parameter to true, you cannot terminate the instances launched with this launch template\n   * using the Amazon EC2 console, CLI, or API; otherwise, you can.\n   *\n   * @default - The API termination setting is not specified in the Launch Template.\n   */\n  readonly disableApiTermination?: boolean;\n\n  /**\n   * Indicates whether the instances are optimized for Amazon EBS I/O. This optimization provides dedicated throughput\n   * to Amazon EBS and an optimized configuration stack to provide optimal Amazon EBS I/O performance. This optimization\n   * isn't available with all instance types. Additional usage charges apply when using an EBS-optimized instance.\n   *\n   * @default - EBS optimization is not specified in the launch template.\n   */\n  readonly ebsOptimized?: boolean;\n\n  /**\n   * If this parameter is set to true, the instance is enabled for AWS Nitro Enclaves; otherwise, it is not enabled for AWS Nitro Enclaves.\n   *\n   * @default - Enablement of Nitro enclaves is not specified in the launch template; defaulting to false.\n   */\n  readonly nitroEnclaveEnabled?: boolean;\n\n  /**\n   * If you set this parameter to true, the instance is enabled for hibernation.\n   *\n   * @default - Hibernation configuration is not specified in the launch template; defaulting to false.\n   */\n  readonly hibernationConfigured?: boolean;\n\n  /**\n   * Indicates whether an instance stops or terminates when you initiate shutdown from the instance (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 - Shutdown behavior is not specified in the launch template; defaults to STOP.\n   */\n  readonly instanceInitiatedShutdownBehavior?: InstanceInitiatedShutdownBehavior;\n\n  /**\n   * If this property is defined, then the Launch Template's InstanceMarketOptions will be\n   * set to use Spot instances, and the options for the Spot instances will be as defined.\n   *\n   * @default - Instance launched with this template will not be spot instances.\n   */\n  readonly spotOptions?: LaunchTemplateSpotOptions;\n\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   * If set to true, then detailed monitoring will be enabled on instances created with this\n   * launch template.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch-new.html\n   *\n   * @default False - Detailed monitoring is disabled.\n   */\n  readonly detailedMonitoring?: boolean;\n\n  /**\n   * Security group to assign to instances created with the launch template.\n   *\n   * @default No security group is assigned.\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * Whether IMDSv2 should be required on launched instances.\n   *\n   * @default - false\n   */\n  readonly requireImdsv2?: boolean;\n\n  /**\n   * Enables or disables the HTTP metadata endpoint on your instances.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpendpoint\n   *\n   * @default true\n   */\n  readonly httpEndpoint?: boolean;\n\n  /**\n   * Enables or disables the IPv6 endpoint for the instance metadata service.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpprotocolipv6\n   *\n   * @default true\n   */\n  readonly httpProtocolIpv6?: boolean;\n\n  /**\n   * The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further instance metadata requests can travel.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpputresponsehoplimit\n   *\n   * @default 1\n   */\n  readonly httpPutResponseHopLimit?: number;\n\n  /**\n   * The state of token usage for your instance metadata requests.  The default state is `optional` if not specified. However,\n   * if requireImdsv2 is true, the state must be `required`.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httptokens\n   *\n   * @default LaunchTemplateHttpTokens.OPTIONAL\n   */\n  readonly httpTokens?: LaunchTemplateHttpTokens;\n\n  /**\n   * Set to enabled to allow access to instance tags from the instance metadata. Set to disabled to turn off access to instance tags from the instance metadata.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-instancemetadatatags\n   *\n   * @default false\n   */\n  readonly instanceMetadataTags?: boolean;\n\n  /**\n   * Whether instances should have a public IP addresses associated with them.\n   *\n   * @default - Use subnet settings\n   */\n  readonly associatePublicIpAddress?: boolean;\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/**\n * A class that provides convenient access to special version tokens for LaunchTemplate\n * versions.\n */\nexport class LaunchTemplateSpecialVersions {\n  /**\n   * The special value that denotes that users of a Launch Template should\n   * reference the LATEST version of the template.\n   */\n  public static readonly LATEST_VERSION: string = \"$Latest\";\n\n  /**\n   * The special value that denotes that users of a Launch Template should\n   * reference the DEFAULT version of the template.\n   */\n  public static readonly DEFAULT_VERSION: string = \"$Default\";\n}\n\n/**\n * Attributes for an imported LaunchTemplate.\n */\nexport interface LaunchTemplateAttributes {\n  /**\n   * The version number of this launch template to use\n   *\n   * @default Version: \"$Default\"\n   */\n  readonly versionNumber?: string;\n\n  /**\n   * The identifier of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` may be set.\n   *\n   * @default None\n   */\n  readonly launchTemplateId?: string;\n\n  /**\n   * The name of the Launch Template\n   *\n   * Exactly one of `launchTemplateId` and `launchTemplateName` may be set.\n   *\n   * @default None\n   */\n  readonly launchTemplateName?: string;\n}\n\n/**\n * This represents an EC2 LaunchTemplate.\n *\n * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html\n */\nexport class LaunchTemplate\n  extends AwsConstructBase\n  implements ILaunchTemplate, iam.IGrantable, IConnectable\n{\n  /**\n   * Import an existing LaunchTemplate.\n   */\n  public static fromLaunchTemplateAttributes(\n    scope: Construct,\n    id: string,\n    attrs: LaunchTemplateAttributes,\n  ): ILaunchTemplate {\n    const haveId = Boolean(attrs.launchTemplateId);\n    const haveName = Boolean(attrs.launchTemplateName);\n    if (haveId == haveName) {\n      throw new Error(\n        \"LaunchTemplate.fromLaunchTemplateAttributes() requires exactly one of launchTemplateId or launchTemplateName be provided.\",\n      );\n    }\n\n    class Import extends AwsConstructBase implements ILaunchTemplate {\n      public get launchTemplateOutputs(): LaunchTemplateOutputs {\n        return {\n          versionNumber: this.versionNumber,\n          launchTemplateId: this.launchTemplateId,\n          launchTemplateName: this.launchTemplateName,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.launchTemplateOutputs;\n      }\n      public readonly versionNumber =\n        attrs.versionNumber ?? LaunchTemplateSpecialVersions.DEFAULT_VERSION;\n      public readonly launchTemplateId? = attrs.launchTemplateId;\n      public readonly launchTemplateName? = attrs.launchTemplateName;\n    }\n    return new Import(scope, id);\n  }\n\n  // ============================================\n  //   Members for ILaunchTemplate/ITerraConstruct interface\n\n  public get launchTemplateOutputs(): LaunchTemplateOutputs {\n    return {\n      versionNumber: this.versionNumber,\n      launchTemplateId: this.launchTemplateId,\n      launchTemplateName: this.launchTemplateName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.launchTemplateOutputs;\n  }\n  public readonly versionNumber: string;\n  public readonly launchTemplateId?: string;\n  public readonly launchTemplateName?: string;\n\n  // =============================================\n  //   Data members\n\n  /**\n   * The default version for the launch template.\n   *\n   * @attribute\n   */\n  public readonly defaultVersionNumber: string;\n\n  /**\n   * The latest version of the launch template.\n   *\n   * @attribute\n   */\n  public readonly latestVersionNumber: string;\n\n  /**\n   * The type of OS the instance is running.\n   *\n   * @attribute\n   */\n  public readonly osType?: OperatingSystemType;\n\n  /**\n   * The AMI ID of the image to use\n   *\n   * @attribute\n   */\n  public readonly imageId?: string;\n\n  /**\n   * IAM Role assumed by instances that are launched from this template.\n   *\n   * @attribute\n   */\n  public readonly role?: iam.IRole;\n\n  /**\n   * UserData executed by instances that are launched from this template.\n   *\n   * @attribute\n   */\n  public readonly userData?: UserData;\n\n  /**\n   * Type of instance to launch.\n   *\n   * @attribute\n   */\n  public readonly instanceType?: InstanceType;\n\n  public readonly resource: tfLaunchTemplate.LaunchTemplate;\n\n  // =============================================\n  //   Private/protected data members\n\n  /**\n   * Principal to grant permissions to.\n   * @internal\n   */\n  protected readonly _grantPrincipal?: iam.IPrincipal;\n\n  /**\n   * Allows specifying security group connections for the instance.\n   * @internal\n   */\n  protected readonly _connections?: Connections;\n\n  // /**\n  //  * TagManager for tagging support.\n  //  */\n  // protected readonly tags: TagManager;\n\n  // isTaggableConstruct required properties\n  private _tags: Record<string, string> | undefined = undefined;\n  public set tags(value: Record<string, string>) {\n    this._tags = value;\n  }\n  public get tags(): Record<string, string> {\n    return Token.asStringMap(\n      Lazy.anyValue({\n        produce: () => this._tags ?? undefined,\n      }),\n    );\n  }\n  // Temporarily expose input value. Use with caution.\n  public get tagsInput(): Record<string, string> | undefined {\n    return this._tags;\n  }\n\n  constructor(scope: Construct, id: string, props: LaunchTemplateProps = {}) {\n    super(scope, id);\n\n    // Basic validation of the provided spot block duration\n    const spotDuration = props?.spotOptions?.blockDuration?.toHours({\n      integral: true,\n    });\n    if (spotDuration !== undefined && (spotDuration < 1 || spotDuration > 6)) {\n      // See: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html#fixed-duration-spot-instances\n      Annotations.of(this).addError(\n        \"Spot block duration must be exactly 1, 2, 3, 4, 5, or 6 hours.\",\n      );\n    }\n\n    // Basic validation of the provided httpPutResponseHopLimit\n    if (\n      props.httpPutResponseHopLimit !== undefined &&\n      (props.httpPutResponseHopLimit < 1 || props.httpPutResponseHopLimit > 64)\n    ) {\n      // See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-metadataoptions.html#cfn-ec2-launchtemplate-launchtemplatedata-metadataoptions-httpputresponsehoplimit\n      Annotations.of(this).addError(\n        \"HttpPutResponseHopLimit must between 1 and 64\",\n      );\n    }\n\n    if (props.instanceProfile && props.role) {\n      throw new Error(\"You cannot provide both an instanceProfile and a role\");\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    // use provided instance profile or create one if a role was provided\n    let iamProfileArn: string | undefined = undefined;\n    if (props.instanceProfile) {\n      this.role = props.instanceProfile.role;\n      iamProfileArn = props.instanceProfile.instanceProfileArn;\n    } else if (props.role) {\n      this.role = props.role;\n      const iamProfile = new tfIamInstanceProfile.IamInstanceProfile(\n        this,\n        \"Profile\",\n        {\n          role: this.role.roleName,\n        },\n      );\n      iamProfileArn = iamProfile.arn;\n    }\n\n    this._grantPrincipal = this.role;\n\n    if (props.securityGroup) {\n      this._connections = new Connections({\n        securityGroups: [props.securityGroup],\n      });\n    }\n    const securityGroupsToken = Lazy.listValue({\n      produce: () => {\n        if (this._connections && this._connections.securityGroups.length > 0) {\n          return this._connections.securityGroups.map(\n            (sg) => sg.securityGroupId,\n          );\n        }\n        return undefined;\n      },\n    });\n\n    const imageConfig: MachineImageConfig | undefined =\n      props.machineImage?.getImage(this);\n    if (imageConfig) {\n      this.osType = imageConfig.osType;\n      this.imageId = imageConfig.imageId;\n    }\n\n    if (\n      this.osType &&\n      props.keyPair &&\n      !props.keyPair._isOsCompatible(this.osType)\n    ) {\n      throw new Error(\n        `${props.keyPair.type} keys are not compatible with the chosen AMI`,\n      );\n    }\n\n    // priority: prop.userData -> userData from machineImage -> undefined\n    this.userData = props.userData ?? imageConfig?.userData;\n    this.instanceType = props.instanceType;\n\n    let marketOptions: any = undefined;\n    if (props?.spotOptions) {\n      marketOptions = {\n        marketType: \"spot\",\n        spotOptions: {\n          blockDurationMinutes:\n            spotDuration !== undefined ? spotDuration * 60 : undefined,\n          instanceInterruptionBehavior: props.spotOptions.interruptionBehavior,\n          maxPrice: props.spotOptions.maxPrice?.toString(),\n          spotInstanceType: props.spotOptions.requestType,\n          validUntil: props.spotOptions.validUntil?.date.toUTCString(),\n        },\n      };\n      // Remove SpotOptions if there are none.\n      if (\n        Object.keys(marketOptions.spotOptions).filter(\n          (k) => marketOptions.spotOptions[k],\n        ).length == 0\n      ) {\n        marketOptions.spotOptions = undefined;\n      }\n    }\n\n    // this.tags = new TagManager(\n    //   TagType.KEY_VALUE,\n    //   tfLaunchTemplate.LaunchTemplate.tfResourceType,\n    // );\n\n    const tagsToken = Lazy.anyValue({\n      produce: ():\n        | tfLaunchTemplate.LaunchTemplateTagSpecifications[]\n        | undefined => {\n        if (this._tags) {\n          return [\n            {\n              resourceType: \"instance\",\n              tags: this._tags,\n            },\n            {\n              resourceType: \"volume\",\n              tags: this._tags,\n            },\n            {\n              resourceType: \"launch-template\",\n              tags: this._tags,\n            },\n          ].map(tfLaunchTemplate.launchTemplateTagSpecificationsToTerraform);\n        }\n        return undefined;\n      },\n    });\n\n    const networkInterfaces:\n      | tfLaunchTemplate.LaunchTemplateNetworkInterfaces[]\n      | undefined =\n      props.associatePublicIpAddress !== undefined\n        ? [\n            {\n              deviceIndex: 0,\n              associatePublicIpAddress:\n                props.associatePublicIpAddress?.toString(),\n              securityGroups: securityGroupsToken,\n            },\n          ]\n        : undefined;\n\n    if (\n      props.versionDescription &&\n      !Token.isUnresolved(props.versionDescription) &&\n      props.versionDescription.length > 255\n    ) {\n      throw new Error(\n        `versionDescription must be less than or equal to 255 characters, got ${props.versionDescription.length}`,\n      );\n    }\n\n    this.resource = new tfLaunchTemplate.LaunchTemplate(this, \"Resource\", {\n      name: props?.launchTemplateName,\n      description: props?.versionDescription,\n      blockDeviceMappings:\n        props?.blockDevices !== undefined\n          ? launchTemplateBlockDeviceMappings(this, props.blockDevices)\n          : undefined,\n      creditSpecification:\n        props?.cpuCredits !== undefined\n          ? {\n              cpuCredits: props.cpuCredits,\n            }\n          : undefined,\n      disableApiTermination: props?.disableApiTermination,\n      ebsOptimized: props?.ebsOptimized?.toString(),\n      enclaveOptions:\n        props?.nitroEnclaveEnabled !== undefined\n          ? {\n              enabled: props.nitroEnclaveEnabled,\n            }\n          : undefined,\n      hibernationOptions:\n        props?.hibernationConfigured !== undefined\n          ? {\n              configured: props.hibernationConfigured,\n            }\n          : undefined,\n      iamInstanceProfile:\n        iamProfileArn !== undefined ? { arn: iamProfileArn } : undefined,\n      imageId: imageConfig?.imageId,\n      instanceType: props?.instanceType?.toString(),\n      instanceInitiatedShutdownBehavior:\n        props?.instanceInitiatedShutdownBehavior,\n      instanceMarketOptions: marketOptions,\n      keyName: props.keyPair?.keyPairName ?? props?.keyName,\n      monitoring:\n        props?.detailedMonitoring !== undefined\n          ? {\n              enabled: props.detailedMonitoring,\n            }\n          : undefined,\n      vpcSecurityGroupIds: networkInterfaces ? undefined : securityGroupsToken,\n      tagSpecifications: tagsToken,\n      userData: this.userData?.render(this),\n      metadataOptions: this.renderMetadataOptions(props),\n      networkInterfaces,\n\n      // Fields not yet implemented:\n      // ==========================\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-capacityreservationspecification.html\n      // Will require creating an L2 for AWS::EC2::CapacityReservation\n      // capacityReservationSpecification: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata-cpuoptions.html\n      // cpuOptions: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-elasticgpuspecification.html\n      // elasticGpuSpecifications: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-elasticinferenceaccelerators\n      // elasticInferenceAccelerators: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-kernelid\n      // kernelId: undefined,\n      // ramDiskId: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-licensespecifications\n      // Also not implemented in Instance L2\n      // licenseSpecifications: undefined,\n\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-launchtemplatedata.html#cfn-ec2-launchtemplate-launchtemplatedata-tagspecifications\n      // Should be implemented via the Tagging aspect in CDK core. Complication will be that this tagging interface is very unique to LaunchTemplates.\n      // tagSpecification: undefined\n\n      // TODO: use IPlacementGroup in LuanchTemplate\n      // placement: undefined,\n    });\n\n    if (this.role) {\n      this.resource.node.addDependency(this.role);\n    } else if (props.instanceProfile?.role) {\n      this.resource.node.addDependency(props.instanceProfile.role);\n    }\n\n    Tags.of(this).add(NAME_TAG, this.node.path);\n\n    this.defaultVersionNumber = this.resource.defaultVersion.toString(); // should be Token.asString()?\n    this.latestVersionNumber = this.resource.latestVersion.toString(); // should be Token.asString()?\n    this.launchTemplateId = this.resource.id;\n    this.versionNumber = this.resource.latestVersion.toString();\n  }\n\n  private renderMetadataOptions(props: LaunchTemplateProps) {\n    let requireMetadataOptions = false;\n    // if requireImdsv2 is true, httpTokens must be required.\n    if (\n      props.requireImdsv2 === true &&\n      props.httpTokens === LaunchTemplateHttpTokens.OPTIONAL\n    ) {\n      Annotations.of(this).addError(\n        \"httpTokens must be required when requireImdsv2 is true\",\n      );\n    }\n    if (\n      props.httpEndpoint !== undefined ||\n      props.httpProtocolIpv6 !== undefined ||\n      props.httpPutResponseHopLimit !== undefined ||\n      props.httpTokens !== undefined ||\n      props.instanceMetadataTags !== undefined ||\n      props.requireImdsv2 === true\n    ) {\n      requireMetadataOptions = true;\n    }\n    if (requireMetadataOptions) {\n      return {\n        httpEndpoint:\n          props.httpEndpoint === true\n            ? \"enabled\"\n            : props.httpEndpoint === false\n              ? \"disabled\"\n              : undefined,\n        httpProtocolIpv6:\n          props.httpProtocolIpv6 === true\n            ? \"enabled\"\n            : props.httpProtocolIpv6 === false\n              ? \"disabled\"\n              : undefined,\n        httpPutResponseHopLimit: props.httpPutResponseHopLimit,\n        httpTokens:\n          props.requireImdsv2 === true\n            ? LaunchTemplateHttpTokens.REQUIRED\n            : props.httpTokens,\n        instanceMetadataTags:\n          props.instanceMetadataTags === true\n            ? \"enabled\"\n            : props.instanceMetadataTags === false\n              ? \"disabled\"\n              : undefined,\n      };\n    } else {\n      return undefined;\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    if (!this._connections) {\n      throw new Error(\n        \"LaunchTemplate can only be added a securityGroup if another securityGroup is initialized in the constructor.\",\n      );\n    }\n    this._connections.addSecurityGroup(securityGroup);\n  }\n\n  /**\n   * Allows specifying security group connections for the instance.\n   *\n   * @note Only available if you provide a securityGroup when constructing the LaunchTemplate.\n   */\n  public get connections(): Connections {\n    if (!this._connections) {\n      throw new Error(\n        \"LaunchTemplate can only be used as IConnectable if a securityGroup is provided when constructing it.\",\n      );\n    }\n    return this._connections;\n  }\n\n  /**\n   * Principal to grant permissions to.\n   *\n   * @note Only available if you provide a role when constructing the LaunchTemplate.\n   */\n  public get grantPrincipal(): iam.IPrincipal {\n    if (!this._grantPrincipal) {\n      throw new Error(\n        \"LaunchTemplate can only be used as IGrantable if a role is provided when constructing it.\",\n      );\n    }\n    return this._grantPrincipal;\n  }\n}\n"]}

package/lib/aws/compute/lb-shared/access-logs-accounts.d.ts

@@ -0,0 +1,7 @@
+export declare const ELBV2_ACCOUNTS: {
+    [region: string]: string;
+};
+/**
+ * The account ID for ELBv2 in this region
+ */
+export declare function getElbv2Account(region: string): string | undefined;