@aws-cdk/aws-imagebuilder-alpha 2.226.0-alpha.0 → 2.228.0-alpha.0

package/lib/component.js

@@ -0,0 +1,970 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = exports.AwsMarketplaceComponent = exports.AwsManagedComponent = exports.S3ComponentData = exports.ComponentData = exports.ComponentStepIfCondition = exports.ComponentStepInputs = exports.ComponentSchemaVersion = exports.ComponentPhaseName = exports.ComponentParameterType = exports.ComponentOnFailure = exports.ComponentAction = exports.ComponentConstantValue = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_imagebuilder_1 = require("aws-cdk-lib/aws-imagebuilder");
+const s3assets = require("aws-cdk-lib/aws-s3-assets");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const yaml = require("yaml");
+const os_version_1 = require("./os-version");
+const COMPONENT_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.Component');
+const LATEST_VERSION = 'x.x.x';
+/**
+ * The value of a constant in a component document
+ */
+class ComponentConstantValue {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ComponentConstantValue", version: "2.228.0-alpha.0" };
+    /**
+     * Creates a string type constant in a component document
+     *
+     * @param value The value of the constant
+     */
+    static fromString(value) {
+        return new ComponentConstantValue('string', value);
+    }
+    /**
+     * The data type of the constant
+     */
+    type;
+    /**
+     * The value of the constant
+     */
+    value;
+    constructor(type, value) {
+        this.type = type;
+        this.value = value;
+    }
+}
+exports.ComponentConstantValue = ComponentConstantValue;
+/**
+ * The action for a step within the component document
+ */
+var ComponentAction;
+(function (ComponentAction) {
+    /**
+     * The AppendFile action adds the provided content to the pre-existing content of a file
+     */
+    ComponentAction["APPEND_FILE"] = "AppendFile";
+    /**
+     * The Assert action performs value with comparison/logic operators, and succeeds/fails the step based on the outcome
+     * of the assertion
+     */
+    ComponentAction["ASSERT"] = "Assert";
+    /**
+     * The CopyFile action copies files from a source file to a destination
+     */
+    ComponentAction["COPY_FILE"] = "CopyFile";
+    /**
+     * The CopyFolder action copies folders from a source to a destination
+     */
+    ComponentAction["COPY_FOLDER"] = "CopyFolder";
+    /**
+     * The CreateFile action creates a file in the provided location
+     */
+    ComponentAction["CREATE_FILE"] = "CreateFile";
+    /**
+     * The CreateFolder action creates a folder in the provided location
+     */
+    ComponentAction["CREATE_FOLDER"] = "CreateFolder";
+    /**
+     * The CreateSymlink action creates symbolic links from a given path to a target
+     */
+    ComponentAction["CREATE_SYMLINK"] = "CreateSymlink";
+    /**
+     * The DeleteFile action deletes file(s) in the provided location
+     */
+    ComponentAction["DELETE_FILE"] = "DeleteFile";
+    /**
+     * The DeleteFolder action deletes folders in the provided location
+     */
+    ComponentAction["DELETE_FOLDER"] = "DeleteFolder";
+    /**
+     * The ExecuteBash action runs bash scripts with inline bash commands
+     */
+    ComponentAction["EXECUTE_BASH"] = "ExecuteBash";
+    /**
+     * The ExecuteBinary action runs a provided binary executable
+     */
+    ComponentAction["EXECUTE_BINARY"] = "ExecuteBinary";
+    /**
+     * The ExecuteDocument action allows running other component documents from within a given component
+     */
+    ComponentAction["EXECUTE_DOCUMENT"] = "ExecuteDocument";
+    /**
+     * The ExecutePowershell action runs PowerShell scripts with inline PowerShell commands
+     */
+    ComponentAction["EXECUTE_POWERSHELL"] = "ExecutePowerShell";
+    /**
+     * The InstallMSI action runs a Windows application with the provided MSI file
+     */
+    ComponentAction["INSTALL_MSI"] = "InstallMSI";
+    /**
+     * The ListFiles action lists files in the provided folder
+     */
+    ComponentAction["LIST_FILES"] = "ListFiles";
+    /**
+     * The MoveFile action moves files from a source to a destination
+     */
+    ComponentAction["MOVE_FILE"] = "MoveFile";
+    /**
+     * The MoveFolder action moves folders from a source to a destination
+     */
+    ComponentAction["MOVE_FOLDER"] = "MoveFolder";
+    /**
+     * The ReadFile action reads the content of a text file
+     */
+    ComponentAction["READ_FILE"] = "ReadFile";
+    /**
+     * The Reboot action reboots the instance
+     */
+    ComponentAction["REBOOT"] = "Reboot";
+    /**
+     * The SetFileEncoding action modifies the encoding property of an existing file
+     */
+    ComponentAction["SET_FILE_ENCODING"] = "SetFileEncoding";
+    /**
+     * The SetFileOwner action modifies the owner and group ownership properties of an existing file
+     */
+    ComponentAction["SET_FILE_OWNER"] = "SetFileOwner";
+    /**
+     * The SetFolderOwner action recursively modifies the owner and group ownership properties of an existing folder
+     */
+    ComponentAction["SET_FOLDER_OWNER"] = "SetFolderOwner";
+    /**
+     * The SetFilePermissions action modifies the permission of an existing file
+     */
+    ComponentAction["SET_FILE_PERMISSIONS"] = "SetFilePermissions";
+    /**
+     * The SetFolderPermissions action recursively modifies the permissions of an existing folder and all of its subfiles
+     * and subfolders
+     */
+    ComponentAction["SET_FOLDER_PERMISSIONS"] = "SetFolderPermissions";
+    /**
+     * The SetRegistry action sets the value for the specified Windows registry key
+     */
+    ComponentAction["SET_REGISTRY"] = "SetRegistry";
+    /**
+     * The S3Download action downloads an Amazon S3 object/folder to a local destination
+     */
+    ComponentAction["S3_DOWNLOAD"] = "S3Download";
+    /**
+     * The S3Upload action uploads a file or folder to an Amazon S3 location
+     */
+    ComponentAction["S3_UPLOAD"] = "S3Upload";
+    /**
+     * The UninstallMSI action removes a Windows application using an MSI file
+     */
+    ComponentAction["UNINSTALL_MSI"] = "UninstallMSI";
+    /**
+     * The UpdateOS action installs OS updates
+     */
+    ComponentAction["UPDATE_OS"] = "UpdateOS";
+    /**
+     * The WebDownload action downloads files from a URL to a local destination
+     */
+    ComponentAction["WEB_DOWNLOAD"] = "WebDownload";
+})(ComponentAction || (exports.ComponentAction = ComponentAction = {}));
+/**
+ * Specifies what the step should do in case of failure
+ */
+var ComponentOnFailure;
+(function (ComponentOnFailure) {
+    /**
+     * Fails the step and document execution
+     */
+    ComponentOnFailure["ABORT"] = "Abort";
+    /**
+     * Fails the step and proceeds to execute the next step in the document
+     */
+    ComponentOnFailure["CONTINUE"] = "Continue";
+    /**
+     * Ignores the step and proceeds to execute the next step in the document
+     */
+    ComponentOnFailure["IGNORE"] = "Ignore";
+})(ComponentOnFailure || (exports.ComponentOnFailure = ComponentOnFailure = {}));
+/**
+ * The parameter type in a component document
+ */
+var ComponentParameterType;
+(function (ComponentParameterType) {
+    /**
+     * Indicates the parameter value is a string
+     */
+    ComponentParameterType["STRING"] = "string";
+})(ComponentParameterType || (exports.ComponentParameterType = ComponentParameterType = {}));
+/**
+ * The phases of a component document
+ */
+var ComponentPhaseName;
+(function (ComponentPhaseName) {
+    /**
+     * Build phase of the component. This phase is run during the BUILDING phase of the image build.
+     */
+    ComponentPhaseName["BUILD"] = "build";
+    /**
+     * Test phase of the component, executed directly on the instance which is used to build the container image. This
+     * phase is run during the TESTING phase of the image build.
+     */
+    ComponentPhaseName["CONTAINER_HOST_TEST"] = "container-host-test";
+    /**
+     * Test phase of the component. This phase is run during the TESTING phase of the image build.
+     */
+    ComponentPhaseName["TEST"] = "test";
+    /**
+     * Validate phase of the component. This phase is run during the BUILDING phase of the image build, after the build
+     * step of the component is executed.
+     */
+    ComponentPhaseName["VALIDATE"] = "validate";
+})(ComponentPhaseName || (exports.ComponentPhaseName = ComponentPhaseName = {}));
+/**
+ * The schema version of the component
+ */
+var ComponentSchemaVersion;
+(function (ComponentSchemaVersion) {
+    /**
+     * Schema version 1.0 for the component document
+     */
+    ComponentSchemaVersion["V1_0"] = "1.0";
+})(ComponentSchemaVersion || (exports.ComponentSchemaVersion = ComponentSchemaVersion = {}));
+/**
+ * Represents the inputs for a step in the component document
+ */
+class ComponentStepInputs {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ComponentStepInputs", version: "2.228.0-alpha.0" };
+    /**
+     * Creates the input value from an object, for the component step
+     *
+     * @param inputsObject The object containing the input values
+     */
+    static fromObject(inputsObject) {
+        return new ComponentStepInputs(inputsObject);
+    }
+    /**
+     * Creates the input value from a list of input objects, for the component step
+     *
+     * @param inputsObjectList The list of objects containing the input values
+     */
+    static fromList(inputsObjectList) {
+        return new ComponentStepInputs(inputsObjectList);
+    }
+    /**
+     * The rendered input value
+     */
+    inputs;
+    constructor(input) {
+        this.inputs = input;
+    }
+}
+exports.ComponentStepInputs = ComponentStepInputs;
+/**
+ * Represents an `if` condition in the component document
+ */
+class ComponentStepIfCondition {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ComponentStepIfCondition", version: "2.228.0-alpha.0" };
+    /**
+     * Creates the `if` value from an object, for the component step
+     *
+     * @param ifObject The object containing the `if` condition
+     */
+    static fromObject(ifObject) {
+        return new ComponentStepIfCondition(ifObject);
+    }
+    /**
+     * The rendered input value
+     */
+    ifCondition;
+    constructor(ifCondition) {
+        this.ifCondition = ifCondition;
+    }
+}
+exports.ComponentStepIfCondition = ComponentStepIfCondition;
+/**
+ * Helper class for referencing and uploading component data
+ */
+class ComponentData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ComponentData", version: "2.228.0-alpha.0" };
+    /**
+     * Uploads component data from a local file to S3 to use as the component data
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param path The local path to the component data file
+     * @param options S3 asset upload options
+     */
+    static fromAsset(scope, id, path, options = {}) {
+        const asset = new s3assets.Asset(scope, id, { ...options, path });
+        return new S3ComponentDataFromAsset(asset);
+    }
+    /**
+     * References component data from a pre-existing S3 object
+     *
+     * @param bucket The S3 bucket where the component data is stored
+     * @param key The S3 key of the component data file
+     */
+    static fromS3(bucket, key) {
+        return new S3ComponentDataFromBucketKey(bucket, key);
+    }
+    /**
+     * Uses an inline JSON object as the component data
+     *
+     * @param data An inline JSON object representing the component data
+     */
+    static fromJsonObject(data) {
+        const inlineData = yaml.stringify(data, { indent: 2 });
+        return new InlineComponentData(inlineData);
+    }
+    /**
+     * Uses an inline JSON object as the component data, using the ComponentDocument interface
+     *
+     * @param data An inline JSON object representing the component data
+     */
+    static fromComponentDocumentJsonObject(data) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ComponentDocument(data);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromComponentDocumentJsonObject);
+            }
+            throw error;
+        }
+        const { name, description, schemaVersion, constants, parameters, phases } = data;
+        return this.fromJsonObject({
+            ...(name !== undefined && { name }),
+            ...(description !== undefined && { description }),
+            schemaVersion: schemaVersion,
+            ...(constants !== undefined && {
+                constants: Object.entries(constants).map(([constantName, value]) => ({
+                    [constantName]: { type: value.type, value: value.value },
+                })),
+            }),
+            ...(parameters !== undefined && {
+                parameters: Object.entries(parameters).map(([parameterName, value]) => ({ [parameterName]: value })),
+            }),
+            phases: phases.map((phase) => ({
+                name: phase.name,
+                steps: phase.steps.map((step) => ({
+                    name: step.name,
+                    action: step.action,
+                    ...(step.onFailure !== undefined && { onFailure: step.onFailure }),
+                    ...(step.timeout !== undefined && { timeoutSeconds: step.timeout.toSeconds() }),
+                    ...(step.if !== undefined && { if: step.if.ifCondition }),
+                    ...(step.loop !== undefined && { loop: step.loop }),
+                    inputs: step.inputs.inputs,
+                })),
+            })),
+        });
+    }
+    /**
+     * Uses an inline JSON/YAML string as the component data
+     *
+     * @param data An inline JSON/YAML string representing the component data
+     */
+    static fromInline(data) {
+        return new InlineComponentData(data);
+    }
+    /**
+     * The resulting inline string or S3 URL which references the component data
+     */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.ComponentData = ComponentData;
+/**
+ * Helper class for S3-based component data references, containing additional permission grant methods on the S3 object
+ */
+class S3ComponentData extends ComponentData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.S3ComponentData", version: "2.228.0-alpha.0" };
+    isS3Reference = true;
+    bucket;
+    key;
+    constructor(bucket, key) {
+        super(bucket.s3UrlForObject(key));
+        this.bucket = bucket;
+        this.key = key;
+    }
+    /**
+     * Grant put permissions to the given grantee for the component data in S3
+     *
+     * @param grantee The principal
+     */
+    grantPut(grantee) {
+        return this.bucket.grantPut(grantee, this.key);
+    }
+    /**
+     * Grant read permissions to the given grantee for the component data in S3
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.bucket.grantRead(grantee, this.key);
+    }
+}
+exports.S3ComponentData = S3ComponentData;
+class InlineComponentData extends ComponentData {
+    isS3Reference = false;
+    constructor(data) {
+        super(data);
+    }
+}
+class S3ComponentDataFromBucketKey extends S3ComponentData {
+    constructor(bucket, key) {
+        super(bucket, key);
+    }
+}
+class S3ComponentDataFromAsset extends S3ComponentData {
+    constructor(asset) {
+        super(asset.bucket, asset.s3ObjectKey);
+    }
+}
+/**
+ * Helper class for working with AWS-managed components
+ */
+class AwsManagedComponent {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.AwsManagedComponent", version: "2.228.0-alpha.0" };
+    /**
+     * Imports the AWS CLI v2 AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static awsCliV2(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.awsCliV2);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'awsCliV2',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'aws-cli-version-2-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'aws-cli-version-2-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports the hello world AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static helloWorld(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.helloWorld);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'helloWorld',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'hello-world-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'hello-world-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports the Python 3 AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static python3(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.python3);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'python3',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'python-3-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'python-3-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports the reboot AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static reboot(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.reboot);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'reboot',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'reboot-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'reboot-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports the STIG hardening AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     *
+     * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ib-stig.html
+     */
+    static stigBuild(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.stigBuild);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'stigBuild',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'stig-build-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'stig-build-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports the OS update AWS-managed component
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static updateOS(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.updateOS);
+            }
+            throw error;
+        }
+        this.validatePredefinedManagedComponentMethodAttributes({
+            scope,
+            attrs,
+            component: 'updateOS',
+            allowedPlatforms: [os_version_1.Platform.LINUX, os_version_1.Platform.WINDOWS],
+        });
+        if (attrs.platform === os_version_1.Platform.WINDOWS) {
+            return this.fromAwsManagedComponentAttributes(scope, id, {
+                componentName: 'update-windows',
+                componentVersion: attrs.componentVersion,
+            });
+        }
+        return this.fromAwsManagedComponentAttributes(scope, id, {
+            componentName: 'update-linux',
+            componentVersion: attrs.componentVersion,
+        });
+    }
+    /**
+     * Imports an AWS-managed component from its attributes
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static fromAwsManagedComponentAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromAwsManagedComponentAttributes);
+            }
+            throw error;
+        }
+        if (attrs.platform !== undefined) {
+            throw new cdk.ValidationError('platform can only be used with pre-defined AWS-managed component methods, such as updateOS', scope);
+        }
+        if (attrs.componentName === undefined) {
+            throw new cdk.ValidationError('an AWS-managed component name is required', scope);
+        }
+        return Component.fromComponentArn(scope, id, cdk.Stack.of(scope).formatArn({
+            service: 'imagebuilder',
+            account: 'aws',
+            resource: 'component',
+            resourceName: `${attrs.componentName}/${attrs.componentVersion ?? LATEST_VERSION}`,
+        }));
+    }
+    /**
+     * Imports an AWS-managed component from its name
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param awsManagedComponentName - The name of the AWS-managed component
+     */
+    static fromAwsManagedComponentName(scope, id, awsManagedComponentName) {
+        return this.fromAwsManagedComponentAttributes(scope, id, { componentName: awsManagedComponentName });
+    }
+    static validatePredefinedManagedComponentMethodAttributes({ scope, attrs, component, allowedPlatforms, }) {
+        if (attrs.componentName !== undefined) {
+            throw new cdk.ValidationError(`a name is not allowed for ${component}`, scope);
+        }
+        if (attrs.platform === undefined) {
+            throw new cdk.ValidationError(`a platform is required for ${component}`, scope);
+        }
+        if (cdk.Token.isUnresolved(attrs.platform)) {
+            throw new cdk.ValidationError(`platform cannot be a token for ${component}`, scope);
+        }
+        if (!allowedPlatforms.includes(attrs.platform)) {
+            throw new cdk.ValidationError(`${attrs.platform} is not a supported platform for ${component}`, scope);
+        }
+    }
+}
+exports.AwsManagedComponent = AwsManagedComponent;
+/**
+ * Helper class for working with AWS Marketplace components
+ */
+class AwsMarketplaceComponent {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.AwsMarketplaceComponent", version: "2.228.0-alpha.0" };
+    /**
+     * Imports an AWS Marketplace component from its attributes
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The AWS-managed component attributes
+     */
+    static fromAwsMarketplaceComponentAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsMarketplaceComponentAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromAwsMarketplaceComponentAttributes);
+            }
+            throw error;
+        }
+        return Component.fromComponentArn(scope, id, cdk.Stack.of(scope).formatArn({
+            service: 'imagebuilder',
+            account: 'aws-marketplace',
+            resource: 'component',
+            resourceName: `${attrs.componentName}-${attrs.marketplaceProductId}/${attrs.componentVersion ?? LATEST_VERSION}`,
+        }));
+    }
+}
+exports.AwsMarketplaceComponent = AwsMarketplaceComponent;
+/**
+ * A new or imported Component
+ */
+class ComponentBase extends cdk.Resource {
+    /**
+     * Grant custom actions to the given grantee for the component
+     *
+     * @param grantee The principal
+     * @param actions The list of actions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.componentArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant read permissions to the given grantee for the component
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetComponent');
+    }
+}
+/**
+ * Represents an EC2 Image Builder Component.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-components.html
+ */
+let Component = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ComponentBase;
+    var Component = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Component = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.Component", version: "2.228.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.Component';
+        /**
+         * Import an existing component given its ARN.
+         */
+        static fromComponentArn(scope, id, componentArn) {
+            return this.fromComponentAttributes(scope, id, { componentArn });
+        }
+        /**
+         * Import an existing component given its name. The provided name must be normalized by converting all alphabetical
+         * characters to lowercase, and replacing all spaces and underscores with hyphens.
+         */
+        static fromComponentName(scope, id, componentName) {
+            return this.fromComponentAttributes(scope, id, { componentName });
+        }
+        /**
+         * Import an existing component by providing its attributes. If the component name is provided as an attribute, it
+         * must be normalized by converting all alphabetical characters to lowercase, and replacing all spaces and underscores
+         * with hyphens.
+         */
+        static fromComponentAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ComponentAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromComponentAttributes);
+                }
+                throw error;
+            }
+            if (attrs.componentArn && (attrs.componentName || attrs.componentVersion)) {
+                throw new cdk.ValidationError('a componentName or componentVersion cannot be provided when a componentArn is provided', scope);
+            }
+            if (!attrs.componentArn && !attrs.componentName) {
+                throw new cdk.ValidationError('either componentArn or componentName is required', scope);
+            }
+            const componentArn = attrs.componentArn ??
+                cdk.Stack.of(scope).formatArn({
+                    service: 'imagebuilder',
+                    resource: 'component',
+                    resourceName: `${attrs.componentName}/${attrs.componentVersion ?? LATEST_VERSION}`,
+                });
+            const [componentName, componentVersion] = (() => {
+                if (attrs.componentName) {
+                    return [attrs.componentName, attrs.componentVersion ?? LATEST_VERSION];
+                }
+                const componentNameVersion = cdk.Stack.of(scope).splitArn(componentArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+                const componentNameVersionSplit = cdk.Fn.split('/', componentNameVersion);
+                return [cdk.Fn.select(0, componentNameVersionSplit), cdk.Fn.select(1, componentNameVersionSplit)];
+            })();
+            class Import extends ComponentBase {
+                componentArn = componentArn;
+                componentName = componentName;
+                componentVersion = componentVersion;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Return whether the given object is a Component.
+         */
+        static isComponent(x) {
+            return x !== null && typeof x === 'object' && COMPONENT_SYMBOL in x;
+        }
+        /**
+         * The ARN of the component
+         */
+        componentArn;
+        /**
+         * The name of the component
+         */
+        componentName;
+        /**
+         * The version of the component
+         */
+        componentVersion;
+        /**
+         * Whether the component is encrypted
+         */
+        encrypted;
+        /**
+         * The type of the component
+         *
+         * @attribute
+         */
+        componentType;
+        kmsKey;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.componentName ??
+                    cdk.Lazy.string({
+                        produce: () => cdk.Names.uniqueResourceName(this, {
+                            maxLength: 128,
+                            separator: '-',
+                            allowedSpecialCharacters: '-',
+                        }).toLowerCase(), // Enforce lowercase for the auto-generated fallback
+                    }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ComponentProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Component);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, COMPONENT_SYMBOL, { value: true });
+            this.validateComponentName();
+            props.supportedOsVersions?.forEach((osVersion) => {
+                if (osVersion.platform !== props.platform) {
+                    throw new cdk.ValidationError(`os version ${osVersion.osVersion} is not compatible with platform ${props.platform}`, this);
+                }
+            });
+            const componentVersion = props.componentVersion ?? '1.0.0';
+            const supportedOsVersions = props.supportedOsVersions?.filter((osVersion) => osVersion.osVersion !== undefined);
+            const component = new aws_imagebuilder_1.CfnComponent(this, 'Resource', {
+                name: this.physicalName,
+                version: componentVersion,
+                changeDescription: props.changeDescription,
+                description: props.description,
+                platform: props.platform,
+                kmsKeyId: props.kmsKey?.keyArn,
+                tags: props.tags,
+                ...(props.data.isS3Reference ? { uri: props.data.value } : { data: props.data.value }),
+                ...(supportedOsVersions?.length && {
+                    supportedOsVersions: supportedOsVersions.map((osVersion) => osVersion.osVersion),
+                }),
+            });
+            this.componentName = this.getResourceNameAttribute(component.attrName);
+            this.componentArn = this.getResourceArnAttribute(component.attrArn, {
+                service: 'imagebuilder',
+                resource: 'component',
+                resourceName: `${this.physicalName}/${componentVersion}`,
+            });
+            this.componentVersion = componentVersion;
+            this.encrypted = true; // Components are always encrypted
+            this.componentType = component.attrType;
+            this.kmsKey = props.kmsKey;
+        }
+        validateComponentName() {
+            if (cdk.Token.isUnresolved(this.physicalName)) {
+                return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time
+            }
+            if (this.physicalName.length > 128) {
+                throw new cdk.ValidationError(`the componentName cannot be longer than 128 characters, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError(`the componentName cannot contain spaces, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError(`the componentName cannot contain underscores, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError(`the componentName must be lowercase, got: '${this.physicalName}'`, this);
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Component = _classThis;
+})();
+exports.Component = Component;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["component.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CfnComponent } from 'aws-cdk-lib/aws-imagebuilder';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as s3assets from 'aws-cdk-lib/aws-s3-assets';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport { Construct } from 'constructs';\nimport * as yaml from 'yaml';\nimport { OSVersion, Platform } from './os-version';\n\nconst COMPONENT_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.Component');\n\nconst LATEST_VERSION = 'x.x.x';\n\n/**\n * An EC2 Image Builder Component.\n */\nexport interface IComponent extends cdk.IResource {\n  /**\n   * The ARN of the component\n   *\n   * @attribute\n   */\n  readonly componentArn: string;\n\n  /**\n   * The name of the component\n   *\n   * @attribute\n   */\n  readonly componentName: string;\n\n  /**\n   * The version of the component\n   *\n   * @attribute\n   */\n  readonly componentVersion: string;\n\n  /**\n   * Grant custom actions to the given grantee for the component\n   *\n   * @param grantee The principal\n   * @param actions The list of actions\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Grant read permissions to the given grantee for the component\n   *\n   * @param grantee The principal\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Properties for creating a Component resource\n */\nexport interface ComponentProps {\n  /**\n   * The component document content that defines the build, validation, or test steps to be executed during the image\n   * building process.\n   */\n  readonly data: ComponentData;\n\n  /**\n   * The operating system platform of the component.\n   */\n  readonly platform: Platform;\n\n  /**\n   * The name of the component.\n   *\n   * @default - a name is generated\n   */\n  readonly componentName?: string;\n\n  /**\n   * The version of the component.\n   *\n   * @default 1.0.0\n   */\n  readonly componentVersion?: string;\n\n  /**\n   * The description of the component.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The change description of the component. Describes what change has been made in this version of the component, or\n   * what makes this version different from other versions.\n   *\n   * @default None\n   */\n  readonly changeDescription?: string;\n\n  /**\n   * The KMS key used to encrypt this component.\n   *\n   * @default - an Image Builder owned key will be used to encrypt the component.\n   */\n  readonly kmsKey?: kms.IKey;\n\n  /**\n   * The operating system versions supported by the component.\n   *\n   * @default None\n   */\n  readonly supportedOsVersions?: OSVersion[];\n\n  /**\n   * The tags to apply to the component\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Properties for an EC2 Image Builder component\n */\nexport interface ComponentAttributes {\n  /**\n   * The ARN of the component\n   *\n   * @default - the ARN is automatically constructed if a componentName is provided, otherwise a componentArn is\n   *            required\n   */\n  readonly componentArn?: string;\n\n  /**\n   * The name of the component\n   *\n   * @default - the name is automatically constructed if a componentArn is provided, otherwise a componentName is\n   *            required\n   */\n  readonly componentName?: string;\n\n  /**\n   * The version of the component\n   *\n   * @default - the latest version of the component, x.x.x\n   */\n  readonly componentVersion?: string;\n}\n\n/**\n * Properties for an EC2 Image Builder AWS-managed component\n */\nexport interface AwsManagedComponentAttributes {\n  /**\n   * The name of the AWS-managed component\n   *\n   * The name of the AWS-managed component. This is a required attribute when using the\n   * `this.fromAwsManagedComponentAttributes()` method. This parameter should not be provided when\n   * using the pre-defined managed component methods, such as `AwsManagedComponent.updateOS()` and\n   * `AwsManagedComponent.reboot()`.\n   *\n   *  @default - none if using  the pre-defined managed component methods, otherwise a platform is required when using\n   *             `this.fromAwsManagedComponentAttributes()`\n   */\n  readonly componentName?: string;\n\n  /**\n   * The version of the AWS-managed component\n   *\n   * @default - the latest version of the component, x.x.x\n   */\n  readonly componentVersion?: string;\n\n  /**\n   * The platform of the AWS-managed component. This is a required attribute when using the pre-defined managed\n   * component methods, such as `AwsManagedComponent.updateOS()` and `AwsManagedComponent.reboot()`. This parameter\n   * should not be provided when using the `this.fromAwsManagedComponentAttributes()` method.\n   *\n   * @default - none if using `this.fromAwsManagedComponentAttributes()`, otherwise a platform is\n   *            required when using the pre-defined managed component methods\n   */\n  readonly platform?: Platform;\n}\n\n/**\n * Properties for an EC2 Image Builder AWS Marketplace component\n */\nexport interface AwsMarketplaceComponentAttributes {\n  /**\n   * The name of the AWS Marketplace component. This name should exclude the marketplace product ID from it\n   */\n  readonly componentName: string;\n\n  /**\n   * The marketplace product ID associated with the component\n   */\n  readonly marketplaceProductId: string;\n\n  /**\n   * The version of the AWS Marketplace component\n   *\n   * @default - the latest version of the component, x.x.x\n   */\n  readonly componentVersion?: string;\n}\n\n/**\n * Properties of an EC2 Image Builder Component Document\n */\nexport interface ComponentDocument {\n  /**\n   * The schema version of the component\n   */\n  readonly schemaVersion: ComponentSchemaVersion;\n\n  /**\n   * The phases which define the grouping of steps to run in the build and test workflows of the image build.\n   */\n  readonly phases: ComponentDocumentPhase[];\n\n  /**\n   * The name of the document\n   *\n   * @default None\n   */\n  readonly name?: string;\n\n  /**\n   * The description of the document\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The constants to define in the document\n   *\n   * @default None\n   */\n  readonly constants?: { [constantName: string]: ComponentConstantValue };\n\n  /**\n   * The parameters to define in the document\n   *\n   * @default None\n   */\n  readonly parameters?: { [parameterName: string]: ComponentDocumentParameterDefinition };\n}\n\n/**\n * The phase to run in a specific workflow in an image build, which define the steps to execute to customize or test\n * the instance.\n */\nexport interface ComponentDocumentPhase {\n  /**\n   * The name of the phase\n   */\n  readonly name: ComponentPhaseName;\n\n  /**\n   * The list of steps to execute to modify or test the build/test instance\n   */\n  readonly steps: ComponentDocumentStep[];\n}\n\n/**\n * The step to run in a specific phase of the image build, which defines the step to execute to customize or test the\n * instance.\n */\nexport interface ComponentDocumentStep {\n  /**\n   * The name of the step\n   */\n  readonly name: string;\n\n  /**\n   * The action to perform in the step\n   */\n  readonly action: ComponentAction;\n\n  /**\n   * Contains parameters required by the action to run the step\n   *\n   * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/toe-action-modules.html\n   */\n  readonly inputs: ComponentStepInputs;\n\n  /**\n   * The condition to apply to the step. If the condition is false, then the step is skipped\n   *\n   * @default - no condition is applied to the step and it gets executed\n   *\n   * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/toe-conditional-constructs.html\n   * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/toe-comparison-operators.html\n   */\n  readonly if?: ComponentStepIfCondition;\n\n  /**\n   * A looping construct defining a repeated sequence of instructions\n   *\n   * @default None\n   */\n  readonly loop?: ComponentDocumentLoop;\n\n  /**\n   * The timeout of the step\n   *\n   * @default - 120 minutes\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n   * Specifies what the step should do in case of failure\n   *\n   * @default ComponentOnFailure.ABORT\n   */\n  readonly onFailure?: ComponentOnFailure;\n}\n\n/**\n * The looping construct of a component defines a repeated sequence of instructions\n */\nexport interface ComponentDocumentLoop {\n  /**\n   * The name of the loop, which can be used to reference\n   *\n   * @default loop\n   */\n  readonly name?: string;\n\n  /**\n   * The for loop iterates on a range of integers specified within a boundary outlined by the start and end of the\n   * variables\n   *\n   * @default - none if `forEach` is provided. otherwise, `for` is required.\n   */\n  readonly for?: ComponentDocumentForLoop;\n\n  /**\n   * The forEach loop iterates on an explicit list of values, which can be strings and chained expressions\n   *\n   * @default - none if `for` is provided. otherwise, `forEach` is required.\n   */\n  readonly forEach?: string[];\n}\n\n/**\n * The for loop iterates on a range of integers specified within a boundary outlined by the start and end of the\n * variables. The iterating values are in the set [start, end] and includes boundary values.\n */\nexport interface ComponentDocumentForLoop {\n  /**\n   * Starting value of iteration. Does not accept chaining expressions.\n   */\n  readonly start: number;\n  /**\n   * Ending value of iteration. Does not accept chaining expressions.\n   */\n  readonly end: number;\n  /**\n   * Difference by which an iterating value is updated through addition. It must be a negative or positive non-zero\n   * value. Does not accept chaining expressions.\n   */\n  readonly updateBy: number;\n}\n\n/**\n * The value of a constant in a component document\n */\nexport class ComponentConstantValue {\n  /**\n   * Creates a string type constant in a component document\n   *\n   * @param value The value of the constant\n   */\n  public static fromString(value: string): ComponentConstantValue {\n    return new ComponentConstantValue('string', value);\n  }\n\n  /**\n   * The data type of the constant\n   */\n  public readonly type: string;\n\n  /**\n   * The value of the constant\n   */\n  public readonly value: any;\n\n  protected constructor(type: string, value: any) {\n    this.type = type;\n    this.value = value;\n  }\n}\n\n/**\n * The definition of the parameter\n */\nexport interface ComponentDocumentParameterDefinition {\n  /**\n   * The type of the parameter\n   */\n  readonly type: ComponentParameterType;\n\n  /**\n   * The default value of the parameter\n   *\n   * @default - none, indicating the parameter is required\n   */\n  readonly default?: any;\n\n  /**\n   * The description of the parameter\n   *\n   * @default None\n   */\n  readonly description?: string;\n}\n\n/**\n * The action for a step within the component document\n */\nexport enum ComponentAction {\n  /**\n   * The AppendFile action adds the provided content to the pre-existing content of a file\n   */\n  APPEND_FILE = 'AppendFile',\n\n  /**\n   * The Assert action performs value with comparison/logic operators, and succeeds/fails the step based on the outcome\n   * of the assertion\n   */\n  ASSERT = 'Assert',\n\n  /**\n   * The CopyFile action copies files from a source file to a destination\n   */\n  COPY_FILE = 'CopyFile',\n\n  /**\n   * The CopyFolder action copies folders from a source to a destination\n   */\n  COPY_FOLDER = 'CopyFolder',\n\n  /**\n   * The CreateFile action creates a file in the provided location\n   */\n  CREATE_FILE = 'CreateFile',\n\n  /**\n   * The CreateFolder action creates a folder in the provided location\n   */\n  CREATE_FOLDER = 'CreateFolder',\n\n  /**\n   * The CreateSymlink action creates symbolic links from a given path to a target\n   */\n  CREATE_SYMLINK = 'CreateSymlink',\n\n  /**\n   * The DeleteFile action deletes file(s) in the provided location\n   */\n  DELETE_FILE = 'DeleteFile',\n\n  /**\n   * The DeleteFolder action deletes folders in the provided location\n   */\n  DELETE_FOLDER = 'DeleteFolder',\n\n  /**\n   * The ExecuteBash action runs bash scripts with inline bash commands\n   */\n  EXECUTE_BASH = 'ExecuteBash',\n\n  /**\n   * The ExecuteBinary action runs a provided binary executable\n   */\n  EXECUTE_BINARY = 'ExecuteBinary',\n\n  /**\n   * The ExecuteDocument action allows running other component documents from within a given component\n   */\n  EXECUTE_DOCUMENT = 'ExecuteDocument',\n\n  /**\n   * The ExecutePowershell action runs PowerShell scripts with inline PowerShell commands\n   */\n  EXECUTE_POWERSHELL = 'ExecutePowerShell',\n\n  /**\n   * The InstallMSI action runs a Windows application with the provided MSI file\n   */\n  INSTALL_MSI = 'InstallMSI',\n\n  /**\n   * The ListFiles action lists files in the provided folder\n   */\n  LIST_FILES = 'ListFiles',\n\n  /**\n   * The MoveFile action moves files from a source to a destination\n   */\n  MOVE_FILE = 'MoveFile',\n\n  /**\n   * The MoveFolder action moves folders from a source to a destination\n   */\n  MOVE_FOLDER = 'MoveFolder',\n\n  /**\n   * The ReadFile action reads the content of a text file\n   */\n  READ_FILE = 'ReadFile',\n\n  /**\n   * The Reboot action reboots the instance\n   */\n  REBOOT = 'Reboot',\n\n  /**\n   * The SetFileEncoding action modifies the encoding property of an existing file\n   */\n  SET_FILE_ENCODING = 'SetFileEncoding',\n\n  /**\n   * The SetFileOwner action modifies the owner and group ownership properties of an existing file\n   */\n  SET_FILE_OWNER = 'SetFileOwner',\n\n  /**\n   * The SetFolderOwner action recursively modifies the owner and group ownership properties of an existing folder\n   */\n  SET_FOLDER_OWNER = 'SetFolderOwner',\n\n  /**\n   * The SetFilePermissions action modifies the permission of an existing file\n   */\n  SET_FILE_PERMISSIONS = 'SetFilePermissions',\n\n  /**\n   * The SetFolderPermissions action recursively modifies the permissions of an existing folder and all of its subfiles\n   * and subfolders\n   */\n  SET_FOLDER_PERMISSIONS = 'SetFolderPermissions',\n\n  /**\n   * The SetRegistry action sets the value for the specified Windows registry key\n   */\n  SET_REGISTRY = 'SetRegistry',\n\n  /**\n   * The S3Download action downloads an Amazon S3 object/folder to a local destination\n   */\n  S3_DOWNLOAD = 'S3Download',\n\n  /**\n   * The S3Upload action uploads a file or folder to an Amazon S3 location\n   */\n  S3_UPLOAD = 'S3Upload',\n\n  /**\n   * The UninstallMSI action removes a Windows application using an MSI file\n   */\n  UNINSTALL_MSI = 'UninstallMSI',\n\n  /**\n   * The UpdateOS action installs OS updates\n   */\n  UPDATE_OS = 'UpdateOS',\n\n  /**\n   * The WebDownload action downloads files from a URL to a local destination\n   */\n  WEB_DOWNLOAD = 'WebDownload',\n}\n\n/**\n * Specifies what the step should do in case of failure\n */\nexport enum ComponentOnFailure {\n  /**\n   * Fails the step and document execution\n   */\n  ABORT = 'Abort',\n\n  /**\n   * Fails the step and proceeds to execute the next step in the document\n   */\n  CONTINUE = 'Continue',\n\n  /**\n   * Ignores the step and proceeds to execute the next step in the document\n   */\n  IGNORE = 'Ignore',\n}\n\n/**\n * The parameter type in a component document\n */\nexport enum ComponentParameterType {\n  /**\n   * Indicates the parameter value is a string\n   */\n  STRING = 'string',\n}\n\n/**\n * The phases of a component document\n */\nexport enum ComponentPhaseName {\n  /**\n   * Build phase of the component. This phase is run during the BUILDING phase of the image build.\n   */\n  BUILD = 'build',\n\n  /**\n   * Test phase of the component, executed directly on the instance which is used to build the container image. This\n   * phase is run during the TESTING phase of the image build.\n   */\n  CONTAINER_HOST_TEST = 'container-host-test',\n\n  /**\n   * Test phase of the component. This phase is run during the TESTING phase of the image build.\n   */\n  TEST = 'test',\n\n  /**\n   * Validate phase of the component. This phase is run during the BUILDING phase of the image build, after the build\n   * step of the component is executed.\n   */\n  VALIDATE = 'validate',\n}\n\n/**\n * The schema version of the component\n */\nexport enum ComponentSchemaVersion {\n  /**\n   * Schema version 1.0 for the component document\n   */\n  V1_0 = '1.0',\n}\n\n/**\n * Represents the inputs for a step in the component document\n */\nexport class ComponentStepInputs {\n  /**\n   * Creates the input value from an object, for the component step\n   *\n   * @param inputsObject The object containing the input values\n   */\n  public static fromObject(inputsObject: { [key: string]: any }): ComponentStepInputs {\n    return new ComponentStepInputs(inputsObject);\n  }\n\n  /**\n   * Creates the input value from a list of input objects, for the component step\n   *\n   * @param inputsObjectList The list of objects containing the input values\n   */\n  public static fromList(inputsObjectList: { [key: string]: any }[]): ComponentStepInputs {\n    return new ComponentStepInputs(inputsObjectList);\n  }\n\n  /**\n   * The rendered input value\n   */\n  public readonly inputs: any;\n\n  protected constructor(input: any) {\n    this.inputs = input;\n  }\n}\n\n/**\n * Represents an `if` condition in the component document\n */\nexport class ComponentStepIfCondition {\n  /**\n   * Creates the `if` value from an object, for the component step\n   *\n   * @param ifObject The object containing the `if` condition\n   */\n  public static fromObject(ifObject: { [key: string]: any }): ComponentStepIfCondition {\n    return new ComponentStepIfCondition(ifObject);\n  }\n\n  /**\n   * The rendered input value\n   */\n  public readonly ifCondition: any;\n\n  protected constructor(ifCondition: any) {\n    this.ifCondition = ifCondition;\n  }\n}\n\n/**\n * Helper class for referencing and uploading component data\n */\nexport abstract class ComponentData {\n  /**\n   * Uploads component data from a local file to S3 to use as the component data\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param path The local path to the component data file\n   * @param options S3 asset upload options\n   */\n  public static fromAsset(\n    scope: Construct,\n    id: string,\n    path: string,\n    options: s3assets.AssetOptions = {},\n  ): S3ComponentData {\n    const asset = new s3assets.Asset(scope, id, { ...options, path });\n    return new S3ComponentDataFromAsset(asset);\n  }\n\n  /**\n   * References component data from a pre-existing S3 object\n   *\n   * @param bucket The S3 bucket where the component data is stored\n   * @param key The S3 key of the component data file\n   */\n  public static fromS3(bucket: s3.IBucket, key: string): S3ComponentData {\n    return new S3ComponentDataFromBucketKey(bucket, key);\n  }\n\n  /**\n   * Uses an inline JSON object as the component data\n   *\n   * @param data An inline JSON object representing the component data\n   */\n  public static fromJsonObject(data: { [key: string]: any }): ComponentData {\n    const inlineData = yaml.stringify(data, { indent: 2 });\n    return new InlineComponentData(inlineData);\n  }\n\n  /**\n   * Uses an inline JSON object as the component data, using the ComponentDocument interface\n   *\n   * @param data An inline JSON object representing the component data\n   */\n  public static fromComponentDocumentJsonObject(data: ComponentDocument): ComponentData {\n    const { name, description, schemaVersion, constants, parameters, phases } = data;\n    return this.fromJsonObject({\n      ...(name !== undefined && { name }),\n      ...(description !== undefined && { description }),\n      schemaVersion: schemaVersion,\n      ...(constants !== undefined && {\n        constants: Object.entries(constants).map(([constantName, value]) => ({\n          [constantName]: { type: value.type, value: value.value },\n        })),\n      }),\n      ...(parameters !== undefined && {\n        parameters: Object.entries(parameters).map(([parameterName, value]) => ({ [parameterName]: value })),\n      }),\n      phases: phases.map((phase) => ({\n        name: phase.name,\n        steps: phase.steps.map((step) => ({\n          name: step.name,\n          action: step.action,\n          ...(step.onFailure !== undefined && { onFailure: step.onFailure }),\n          ...(step.timeout !== undefined && { timeoutSeconds: step.timeout.toSeconds() }),\n          ...(step.if !== undefined && { if: step.if.ifCondition }),\n          ...(step.loop !== undefined && { loop: step.loop }),\n          inputs: step.inputs.inputs,\n        })),\n      })),\n    });\n  }\n\n  /**\n   * Uses an inline JSON/YAML string as the component data\n   *\n   * @param data An inline JSON/YAML string representing the component data\n   */\n  public static fromInline(data: string): ComponentData {\n    return new InlineComponentData(data);\n  }\n\n  /**\n   * Indicates that the provided component data is an S3 reference\n   */\n  abstract readonly isS3Reference: boolean;\n\n  /**\n   * The resulting inline string or S3 URL which references the component data\n   */\n  public readonly value: string;\n\n  protected constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Helper class for S3-based component data references, containing additional permission grant methods on the S3 object\n */\nexport abstract class S3ComponentData extends ComponentData {\n  public readonly isS3Reference = true;\n\n  protected readonly bucket: s3.IBucket;\n  protected readonly key: string;\n\n  protected constructor(bucket: s3.IBucket, key: string) {\n    super(bucket.s3UrlForObject(key));\n\n    this.bucket = bucket;\n    this.key = key;\n  }\n\n  /**\n   * Grant put permissions to the given grantee for the component data in S3\n   *\n   * @param grantee The principal\n   */\n  public grantPut(grantee: iam.IGrantable): iam.Grant {\n    return this.bucket.grantPut(grantee, this.key);\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the component data in S3\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.bucket.grantRead(grantee, this.key);\n  }\n}\n\nclass InlineComponentData extends ComponentData {\n  public readonly isS3Reference = false;\n\n  public constructor(data: string) {\n    super(data);\n  }\n}\n\nclass S3ComponentDataFromBucketKey extends S3ComponentData {\n  public constructor(bucket: s3.IBucket, key: string) {\n    super(bucket, key);\n  }\n}\n\nclass S3ComponentDataFromAsset extends S3ComponentData {\n  public constructor(asset: s3assets.Asset) {\n    super(asset.bucket, asset.s3ObjectKey);\n  }\n}\n\n/**\n * Helper class for working with AWS-managed components\n */\nexport abstract class AwsManagedComponent {\n  /**\n   * Imports the AWS CLI v2 AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static awsCliV2(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'awsCliV2',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'aws-cli-version-2-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'aws-cli-version-2-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports the hello world AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static helloWorld(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'helloWorld',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'hello-world-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'hello-world-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports the Python 3 AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static python3(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'python3',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'python-3-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'python-3-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports the reboot AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static reboot(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'reboot',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'reboot-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'reboot-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports the STIG hardening AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   *\n   * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ib-stig.html\n   */\n  public static stigBuild(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'stigBuild',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'stig-build-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'stig-build-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports the OS update AWS-managed component\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static updateOS(scope: Construct, id: string, attrs: AwsManagedComponentAttributes): IComponent {\n    this.validatePredefinedManagedComponentMethodAttributes({\n      scope,\n      attrs,\n      component: 'updateOS',\n      allowedPlatforms: [Platform.LINUX, Platform.WINDOWS],\n    });\n\n    if (attrs.platform === Platform.WINDOWS) {\n      return this.fromAwsManagedComponentAttributes(scope, id, {\n        componentName: 'update-windows',\n        componentVersion: attrs.componentVersion,\n      });\n    }\n\n    return this.fromAwsManagedComponentAttributes(scope, id, {\n      componentName: 'update-linux',\n      componentVersion: attrs.componentVersion,\n    });\n  }\n\n  /**\n   * Imports an AWS-managed component from its attributes\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static fromAwsManagedComponentAttributes(\n    scope: Construct,\n    id: string,\n    attrs: AwsManagedComponentAttributes,\n  ): IComponent {\n    if (attrs.platform !== undefined) {\n      throw new cdk.ValidationError(\n        'platform can only be used with pre-defined AWS-managed component methods, such as updateOS',\n        scope,\n      );\n    }\n\n    if (attrs.componentName === undefined) {\n      throw new cdk.ValidationError('an AWS-managed component name is required', scope);\n    }\n\n    return Component.fromComponentArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        account: 'aws',\n        resource: 'component',\n        resourceName: `${attrs.componentName}/${attrs.componentVersion ?? LATEST_VERSION}`,\n      }),\n    );\n  }\n  /**\n   * Imports an AWS-managed component from its name\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param awsManagedComponentName - The name of the AWS-managed component\n   */\n  public static fromAwsManagedComponentName(scope: Construct, id: string, awsManagedComponentName: string): IComponent {\n    return this.fromAwsManagedComponentAttributes(scope, id, { componentName: awsManagedComponentName });\n  }\n\n  private static validatePredefinedManagedComponentMethodAttributes({\n    scope,\n    attrs,\n    component,\n    allowedPlatforms,\n  }: {\n    scope: Construct;\n    component: string;\n    attrs: AwsManagedComponentAttributes;\n    allowedPlatforms: Platform[];\n  }) {\n    if (attrs.componentName !== undefined) {\n      throw new cdk.ValidationError(`a name is not allowed for ${component}`, scope);\n    }\n\n    if (attrs.platform === undefined) {\n      throw new cdk.ValidationError(`a platform is required for ${component}`, scope);\n    }\n\n    if (cdk.Token.isUnresolved(attrs.platform)) {\n      throw new cdk.ValidationError(`platform cannot be a token for ${component}`, scope);\n    }\n\n    if (!allowedPlatforms.includes(attrs.platform)) {\n      throw new cdk.ValidationError(`${attrs.platform} is not a supported platform for ${component}`, scope);\n    }\n  }\n}\n\n/**\n * Helper class for working with AWS Marketplace components\n */\nexport class AwsMarketplaceComponent {\n  /**\n   * Imports an AWS Marketplace component from its attributes\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The AWS-managed component attributes\n   */\n  public static fromAwsMarketplaceComponentAttributes(\n    scope: Construct,\n    id: string,\n    attrs: AwsMarketplaceComponentAttributes,\n  ): IComponent {\n    return Component.fromComponentArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        account: 'aws-marketplace',\n        resource: 'component',\n        resourceName: `${attrs.componentName}-${attrs.marketplaceProductId}/${attrs.componentVersion ?? LATEST_VERSION}`,\n      }),\n    );\n  }\n}\n\n/**\n * A new or imported Component\n */\nabstract class ComponentBase extends cdk.Resource implements IComponent {\n  /**\n   * The ARN of the component\n   */\n  abstract readonly componentArn: string;\n  /**\n   * The name of the component\n   */\n  abstract readonly componentName: string;\n  /**\n   * The version of the component\n   */\n  abstract readonly componentVersion: string;\n\n  /**\n   * Grant custom actions to the given grantee for the component\n   *\n   * @param grantee The principal\n   * @param actions The list of actions\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.componentArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the component\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetComponent');\n  }\n}\n\n/**\n * Represents an EC2 Image Builder Component.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-components.html\n */\n@propertyInjectable\nexport class Component extends ComponentBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.Component';\n\n  /**\n   * Import an existing component given its ARN.\n   */\n  public static fromComponentArn(scope: Construct, id: string, componentArn: string): IComponent {\n    return this.fromComponentAttributes(scope, id, { componentArn });\n  }\n\n  /**\n   * Import an existing component given its name. The provided name must be normalized by converting all alphabetical\n   * characters to lowercase, and replacing all spaces and underscores with hyphens.\n   */\n  public static fromComponentName(scope: Construct, id: string, componentName: string): IComponent {\n    return this.fromComponentAttributes(scope, id, { componentName });\n  }\n\n  /**\n   * Import an existing component by providing its attributes. If the component name is provided as an attribute, it\n   * must be normalized by converting all alphabetical characters to lowercase, and replacing all spaces and underscores\n   * with hyphens.\n   */\n  public static fromComponentAttributes(scope: Construct, id: string, attrs: ComponentAttributes): IComponent {\n    if (attrs.componentArn && (attrs.componentName || attrs.componentVersion)) {\n      throw new cdk.ValidationError(\n        'a componentName or componentVersion cannot be provided when a componentArn is provided',\n        scope,\n      );\n    }\n\n    if (!attrs.componentArn && !attrs.componentName) {\n      throw new cdk.ValidationError('either componentArn or componentName is required', scope);\n    }\n\n    const componentArn =\n      attrs.componentArn ??\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'component',\n        resourceName: `${attrs.componentName}/${attrs.componentVersion ?? LATEST_VERSION}`,\n      });\n\n    const [componentName, componentVersion] = (() => {\n      if (attrs.componentName) {\n        return [attrs.componentName, attrs.componentVersion ?? LATEST_VERSION];\n      }\n\n      const componentNameVersion = cdk.Stack.of(scope).splitArn(\n        componentArn,\n        cdk.ArnFormat.SLASH_RESOURCE_NAME,\n      ).resourceName!;\n\n      const componentNameVersionSplit = cdk.Fn.split('/', componentNameVersion);\n      return [cdk.Fn.select(0, componentNameVersionSplit), cdk.Fn.select(1, componentNameVersionSplit)];\n    })();\n\n    class Import extends ComponentBase {\n      public readonly componentArn = componentArn;\n      public readonly componentName = componentName;\n      public readonly componentVersion = componentVersion;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Return whether the given object is a Component.\n   */\n  public static isComponent(x: any): x is Component {\n    return x !== null && typeof x === 'object' && COMPONENT_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the component\n   */\n  public readonly componentArn: string;\n\n  /**\n   * The name of the component\n   */\n  public readonly componentName: string;\n\n  /**\n   * The version of the component\n   */\n  public readonly componentVersion: string;\n\n  /**\n   * Whether the component is encrypted\n   */\n  public readonly encrypted: boolean;\n\n  /**\n   * The type of the component\n   *\n   * @attribute\n   */\n  public readonly componentType: string;\n\n  protected readonly kmsKey?: kms.IKey;\n\n  public constructor(scope: Construct, id: string, props: ComponentProps) {\n    super(scope, id, {\n      physicalName:\n        props.componentName ??\n        cdk.Lazy.string({\n          produce: () =>\n            cdk.Names.uniqueResourceName(this, {\n              maxLength: 128,\n              separator: '-',\n              allowedSpecialCharacters: '-',\n            }).toLowerCase(), // Enforce lowercase for the auto-generated fallback\n        }),\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    Object.defineProperty(this, COMPONENT_SYMBOL, { value: true });\n\n    this.validateComponentName();\n\n    props.supportedOsVersions?.forEach((osVersion) => {\n      if (osVersion.platform !== props.platform) {\n        throw new cdk.ValidationError(\n          `os version ${osVersion.osVersion} is not compatible with platform ${props.platform}`,\n          this,\n        );\n      }\n    });\n\n    const componentVersion = props.componentVersion ?? '1.0.0';\n    const supportedOsVersions = props.supportedOsVersions?.filter((osVersion) => osVersion.osVersion !== undefined);\n\n    const component = new CfnComponent(this, 'Resource', {\n      name: this.physicalName,\n      version: componentVersion,\n      changeDescription: props.changeDescription,\n      description: props.description,\n      platform: props.platform,\n      kmsKeyId: props.kmsKey?.keyArn,\n      tags: props.tags,\n      ...(props.data.isS3Reference ? { uri: props.data.value } : { data: props.data.value }),\n      ...(supportedOsVersions?.length && {\n        supportedOsVersions: supportedOsVersions.map((osVersion) => osVersion.osVersion!),\n      }),\n    });\n\n    this.componentName = this.getResourceNameAttribute(component.attrName);\n    this.componentArn = this.getResourceArnAttribute(component.attrArn, {\n      service: 'imagebuilder',\n      resource: 'component',\n      resourceName: `${this.physicalName}/${componentVersion}`,\n    });\n    this.componentVersion = componentVersion;\n    this.encrypted = true; // Components are always encrypted\n    this.componentType = component.attrType;\n    this.kmsKey = props.kmsKey;\n  }\n\n  private validateComponentName() {\n    if (cdk.Token.isUnresolved(this.physicalName)) {\n      return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time\n    }\n\n    if (this.physicalName.length > 128) {\n      throw new cdk.ValidationError(\n        `the componentName cannot be longer than 128 characters, got: '${this.physicalName}'`,\n        this,\n      );\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError(`the componentName cannot contain spaces, got: '${this.physicalName}'`, this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError(`the componentName cannot contain underscores, got: '${this.physicalName}'`, this);\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError(`the componentName must be lowercase, got: '${this.physicalName}'`, this);\n    }\n  }\n}\n"]}