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

package/lib/workflow.js

@@ -0,0 +1,597 @@
+"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.Workflow = exports.AwsManagedWorkflow = exports.S3WorkflowData = exports.WorkflowData = exports.WorkflowType = exports.WorkflowSchemaVersion = exports.WorkflowParameterType = exports.WorkflowOnFailure = exports.WorkflowAction = 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 WORKFLOW_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.Workflow');
+/**
+ * Represents the latest version of a workflow. When using the workflow in a pipeline, the pipeline will use the
+ * latest workflow at the time of execution.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html
+ */
+const LATEST_VERSION = 'x.x.x';
+/**
+ * The action for a step within the workflow document
+ */
+var WorkflowAction;
+(function (WorkflowAction) {
+    /**
+     * Applies customizations and configurations to the input AMIs, such as publishing the AMI to SSM Parameter Store,
+     * or creating launch template versions with the AMI IDs provided in the input
+     */
+    WorkflowAction["APPLY_IMAGE_CONFIGURATIONS"] = "ApplyImageConfigurations";
+    /**
+     * The BootstrapInstanceForContainer action runs a service script to bootstrap the instance with minimum requirements
+     * to run container workflows
+     */
+    WorkflowAction["BOOTSTRAP_INSTANCE_FOR_CONTAINER"] = "BootstrapInstanceForContainer";
+    /**
+     * The CollectImageMetadata action collects additional information about the instance, such as the list of packages
+     * and their respective versions
+     */
+    WorkflowAction["COLLECT_IMAGE_METADATA"] = "CollectImageMetadata";
+    /**
+     * The CollectImageScanFindings action collects findings reported by Amazon Inspector for the provided instance
+     */
+    WorkflowAction["COLLECT_IMAGE_SCAN_FINDINGS"] = "CollectImageScanFindings";
+    /**
+     * The CreateImage action creates an AMI from a running instance with the ec2:CreateImage API
+     */
+    WorkflowAction["CREATE_IMAGE"] = "CreateImage";
+    /**
+     * The DistributeImage action copies an AMI using the image's distribution configuration, or using the distribution
+     * settings in the step input
+     */
+    WorkflowAction["DISTRIBUTE_IMAGE"] = "DistributeImage";
+    /**
+     * The ExecuteComponents action runs components that are specified in the recipe for the current image being built
+     */
+    WorkflowAction["EXECUTE_COMPONENTS"] = "ExecuteComponents";
+    /**
+     * The ExecuteStateMachine action executes a the state machine provided and waits for completion as part of the
+     * workflow
+     */
+    WorkflowAction["EXECUTE_STATE_MACHINE"] = "ExecuteStateMachine";
+    /**
+     * The LaunchInstance action launches an instance using the settings from your recipe and infrastructure configuration
+     * resources
+     */
+    WorkflowAction["LAUNCH_INSTANCE"] = "LaunchInstance";
+    /**
+     * Applies attribute updates to the provided set of distributed images, such as launch permission updates
+     */
+    WorkflowAction["MODIFY_IMAGE_ATTRIBUTES"] = "ModifyImageAttributes";
+    /**
+     * The RunCommand action runs a command document against the provided instance
+     */
+    WorkflowAction["RUN_COMMAND"] = "RunCommand";
+    /**
+     * The RegisterImage action creates an AMI from a set of snapshots with the ec2:RegisterImage API
+     */
+    WorkflowAction["REGISTER_IMAGE"] = "RegisterImage";
+    /**
+     * The RunSysprep action runs the Sysprep document on the provided Windows instance
+     */
+    WorkflowAction["RUN_SYS_PREP"] = "RunSysPrep";
+    /**
+     * The SanitizeInstance action runs a recommended sanitization script on Linux instances
+     */
+    WorkflowAction["SANITIZE_INSTANCE"] = "SanitizeInstance";
+    /**
+     * The TerminateInstance action terminates the provided instance
+     */
+    WorkflowAction["TERMINATE_INSTANCE"] = "TerminateInstance";
+    /**
+     * The WaitForAction action pauses the workflow and waits to receive an external signal from the
+     * imagebuilder:SendWorkflowStepAction API
+     */
+    WorkflowAction["WAIT_FOR_ACTION"] = "WaitForAction";
+    /**
+     * The WaitForSSMAgent action waits for the given instance to have connectivity with SSM before proceeding
+     */
+    WorkflowAction["WAIT_FOR_SSM_AGENT"] = "WaitForSSMAgent";
+})(WorkflowAction || (exports.WorkflowAction = WorkflowAction = {}));
+/**
+ * The action to take if the workflow fails
+ */
+var WorkflowOnFailure;
+(function (WorkflowOnFailure) {
+    /**
+     * Fails the image build if the workflow fails
+     */
+    WorkflowOnFailure["ABORT"] = "Abort";
+    /**
+     * Continues with the image build if the workflow fails
+     */
+    WorkflowOnFailure["CONTINUE"] = "Continue";
+})(WorkflowOnFailure || (exports.WorkflowOnFailure = WorkflowOnFailure = {}));
+/**
+ * The parameter type for the workflow parameter
+ */
+var WorkflowParameterType;
+(function (WorkflowParameterType) {
+    /**
+     * Indicates the workflow parameter has a boolean value
+     */
+    WorkflowParameterType["BOOLEAN"] = "boolean";
+    /**
+     * Indicates the workflow parameter has an integer value
+     */
+    WorkflowParameterType["INTEGER"] = "integer";
+    /**
+     * Indicates the workflow parameter has a string value
+     */
+    WorkflowParameterType["STRING"] = "string";
+    /**
+     * Indicates the workflow parameter has a string list value
+     */
+    WorkflowParameterType["STRING_LIST"] = "stringList";
+})(WorkflowParameterType || (exports.WorkflowParameterType = WorkflowParameterType = {}));
+/**
+ * The schema version of the workflow
+ */
+var WorkflowSchemaVersion;
+(function (WorkflowSchemaVersion) {
+    /**
+     * Schema version 1.0 for the workflow document
+     */
+    WorkflowSchemaVersion["V1_0"] = "1.0";
+})(WorkflowSchemaVersion || (exports.WorkflowSchemaVersion = WorkflowSchemaVersion = {}));
+/**
+ * The type of the workflow
+ */
+var WorkflowType;
+(function (WorkflowType) {
+    /**
+     * Indicates the workflow is for building images
+     */
+    WorkflowType["BUILD"] = "BUILD";
+    /**
+     * Indicates the workflow is for testing images
+     */
+    WorkflowType["TEST"] = "TEST";
+    /**
+     * Indicates the workflow is for distributing images
+     */
+    WorkflowType["DISTRIBUTION"] = "DISTRIBUTION";
+})(WorkflowType || (exports.WorkflowType = WorkflowType = {}));
+/**
+ * Helper class for referencing and uploading workflow data
+ */
+class WorkflowData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.WorkflowData", version: "2.229.1-alpha.0" };
+    /**
+     * Uploads workflow data from a local file to S3 to use as the workflow data
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param path The local path to the workflow 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 S3WorkflowDataFromAsset(asset);
+    }
+    /**
+     * References workflow data from a pre-existing S3 object
+     *
+     * @param bucket The S3 bucket where the workflow data is stored
+     * @param key The S3 key of the workflow data file
+     */
+    static fromS3(bucket, key) {
+        return new S3WorkflowDataFromBucketKey(bucket, key);
+    }
+    /**
+     * Uses an inline JSON object as the workflow data
+     *
+     * @param data An inline JSON object representing the workflow data
+     */
+    static fromJsonObject(data) {
+        const inlineData = yaml.stringify(data, { indent: 2 });
+        return new InlineWorkflowData(inlineData);
+    }
+    /**
+     * Uses an inline JSON or YAML string as the workflow data
+     *
+     * @param data An inline JSON or YAML string representing the workflow data
+     */
+    static fromInline(data) {
+        return new InlineWorkflowData(data);
+    }
+}
+exports.WorkflowData = WorkflowData;
+/**
+ * Helper class for S3-based workflow data references, containing additional permission grant methods on the S3 object
+ */
+class S3WorkflowData extends WorkflowData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.S3WorkflowData", version: "2.229.1-alpha.0" };
+    bucket;
+    key;
+    constructor(bucket, key) {
+        super();
+        this.bucket = bucket;
+        this.key = key;
+    }
+    /**
+     * The rendered workflow data text, for use in CloudFormation
+     */
+    render() {
+        return { uri: this.bucket.s3UrlForObject(this.key) };
+    }
+    /**
+     * Grant put permissions to the given grantee for the workflow 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 workflow data in S3
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.bucket.grantRead(grantee, this.key);
+    }
+}
+exports.S3WorkflowData = S3WorkflowData;
+class InlineWorkflowData extends WorkflowData {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    /**
+     * The rendered workflow data text, for use in CloudFormation
+     */
+    render() {
+        return { data: this.data };
+    }
+}
+class S3WorkflowDataFromBucketKey extends S3WorkflowData {
+    constructor(bucket, key) {
+        super(bucket, key);
+    }
+}
+class S3WorkflowDataFromAsset extends S3WorkflowData {
+    constructor(asset) {
+        super(asset.bucket, asset.s3ObjectKey);
+    }
+}
+/**
+ * Helper class for working with AWS-managed workflows
+ */
+class AwsManagedWorkflow {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.AwsManagedWorkflow", version: "2.229.1-alpha.0" };
+    /**
+     * Imports the build-container AWS-managed workflow
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     */
+    static buildContainer(scope, id) {
+        return this.fromAwsManagedWorkflowAttributes(scope, id, {
+            workflowName: 'build-container',
+            workflowType: WorkflowType.BUILD,
+        });
+    }
+    /**
+     * Imports the build-image AWS-managed workflow
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     */
+    static buildImage(scope, id) {
+        return this.fromAwsManagedWorkflowAttributes(scope, id, {
+            workflowName: 'build-image',
+            workflowType: WorkflowType.BUILD,
+        });
+    }
+    /**
+     * Imports the distribute-container AWS-managed workflow
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     */
+    static distributeContainer(scope, id) {
+        return this.fromAwsManagedWorkflowAttributes(scope, id, {
+            workflowName: 'distribute-container',
+            workflowType: WorkflowType.DISTRIBUTION,
+        });
+    }
+    /**
+     * Imports the test-container AWS-managed workflow
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     */
+    static testContainer(scope, id) {
+        return this.fromAwsManagedWorkflowAttributes(scope, id, {
+            workflowName: 'test-container',
+            workflowType: WorkflowType.TEST,
+        });
+    }
+    /**
+     * Imports the test-image AWS-managed workflow
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     */
+    static testImage(scope, id) {
+        return this.fromAwsManagedWorkflowAttributes(scope, id, {
+            workflowName: 'test-image',
+            workflowType: WorkflowType.TEST,
+        });
+    }
+    /**
+     * Imports an AWS-managed workflow from its attributes
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param attrs The attributes of the AWS-managed workflow
+     */
+    static fromAwsManagedWorkflowAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AwsManagedWorkflowAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromAwsManagedWorkflowAttributes);
+            }
+            throw error;
+        }
+        if (cdk.Token.isUnresolved(attrs.workflowType)) {
+            throw new cdk.ValidationError('workflowType cannot be a token', scope);
+        }
+        return Workflow.fromWorkflowArn(scope, id, cdk.Stack.of(scope).formatArn({
+            service: 'imagebuilder',
+            account: 'aws',
+            resource: 'workflow',
+            resourceName: `${attrs.workflowType.toLowerCase()}/${attrs.workflowName}/${LATEST_VERSION}`,
+        }));
+    }
+}
+exports.AwsManagedWorkflow = AwsManagedWorkflow;
+/**
+ * A new or imported Workflow
+ */
+class WorkflowBase extends cdk.Resource {
+    /**
+     * Grant custom actions to the given grantee for the workflow
+     *
+     * @param grantee The principal
+     * @param actions The list of actions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.workflowArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant read permissions to the given grantee for the workflow
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetWorkflow');
+    }
+}
+/**
+ * Represents an EC2 Image Builder Workflow.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-image-workflows.html
+ */
+let Workflow = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = WorkflowBase;
+    var Workflow = 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);
+            Workflow = _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.Workflow", version: "2.229.1-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.Workflow';
+        /**
+         * Import an existing workflow given its ARN.
+         */
+        static fromWorkflowArn(scope, id, workflowArn) {
+            return this.fromWorkflowAttributes(scope, id, { workflowArn });
+        }
+        /**
+         * Import an existing workflow by providing its attributes. The provided name must be normalized by converting
+         * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens. You may not
+         * provide a dynamic expression for the workflowArn or workflowType
+         */
+        static fromWorkflowAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_WorkflowAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromWorkflowAttributes);
+                }
+                throw error;
+            }
+            if (attrs.workflowArn !== undefined &&
+                (attrs.workflowName !== undefined || attrs.workflowType !== undefined || attrs.workflowVersion !== undefined)) {
+                throw new cdk.ValidationError('a workflowName, workflowType, or workflowVersion cannot be provided when a workflowArn is provided', scope);
+            }
+            if (attrs.workflowArn === undefined && (attrs.workflowName === undefined || attrs.workflowType === undefined)) {
+                throw new cdk.ValidationError('either workflowArn, or workflowName and workflowType is required', scope);
+            }
+            if (attrs.workflowType && cdk.Token.isUnresolved(attrs.workflowType)) {
+                throw new cdk.ValidationError('workflowType cannot be an unresolved token', scope);
+            }
+            const workflowArn = (() => {
+                if (attrs.workflowArn !== undefined) {
+                    return attrs.workflowArn;
+                }
+                return cdk.Stack.of(scope).formatArn({
+                    service: 'imagebuilder',
+                    resource: 'workflow',
+                    resourceName: `${attrs.workflowType.toLowerCase()}/${attrs.workflowName}/${attrs.workflowVersion ?? LATEST_VERSION}`,
+                });
+            })();
+            const [workflowType, workflowName, workflowVersion] = (() => {
+                if (attrs.workflowName !== undefined) {
+                    return [attrs.workflowType.toUpperCase(), attrs.workflowName, attrs.workflowVersion ?? LATEST_VERSION];
+                }
+                const workflowNameTypeVersion = cdk.Stack.of(scope).splitArn(workflowArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+                if (cdk.Token.isUnresolved(workflowNameTypeVersion)) {
+                    throw new cdk.ValidationError('the workflowName, workflowType, and workflowVersion in the workflowArn cannot be an unresolved token', scope);
+                }
+                if (workflowNameTypeVersion.split('/').length < 3) {
+                    throw new cdk.ValidationError('the workflow ARN must end with <workflow-type>/<workflow-name>/<workflow-version>', scope);
+                }
+                const workflowNameTypeVersionSplit = workflowNameTypeVersion.split('/');
+                const [workflowTypeFromArn, workflowNameFromArn, workflowVersionFromArn] = workflowNameTypeVersionSplit.slice(0, 3);
+                return [workflowTypeFromArn.toUpperCase(), workflowNameFromArn, workflowVersionFromArn];
+            })();
+            class Import extends WorkflowBase {
+                workflowArn = workflowArn;
+                workflowName = workflowName;
+                workflowType = workflowType;
+                workflowVersion = workflowVersion;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Return whether the given object is a Workflow.
+         */
+        static isWorkflow(x) {
+            return x !== null && typeof x === 'object' && WORKFLOW_SYMBOL in x;
+        }
+        /**
+         * The ARN of the workflow
+         */
+        workflowArn;
+        /**
+         * The name of the workflow
+         */
+        workflowName;
+        /**
+         * The type of the workflow
+         */
+        workflowType;
+        /**
+         * The version of the workflow
+         */
+        workflowVersion;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.workflowName ??
+                    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_WorkflowProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Workflow);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, WORKFLOW_SYMBOL, { value: true });
+            this.validateWorkflowName();
+            const workflowVersion = props.workflowVersion ?? '1.0.0';
+            const workflow = new aws_imagebuilder_1.CfnWorkflow(this, 'Resource', {
+                name: this.physicalName,
+                version: workflowVersion,
+                type: props.workflowType,
+                changeDescription: props.changeDescription,
+                description: props.description,
+                kmsKeyId: props.kmsKey?.keyArn,
+                tags: props.tags,
+                ...props.data.render(),
+            });
+            this.workflowName = this.getResourceNameAttribute(workflow.getAtt('Name').toString());
+            this.workflowArn = workflow.attrArn;
+            this.workflowVersion = workflowVersion;
+            this.workflowType = props.workflowType;
+        }
+        validateWorkflowName() {
+            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 workflowName cannot be longer than 128 characters', this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError('the workflowName cannot contain spaces', this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError('the workflowName cannot contain underscores', this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError('the workflowName must be lowercase', this);
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Workflow = _classThis;
+})();
+exports.Workflow = Workflow;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.js","sourceRoot":"","sources":["workflow.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 { CfnWorkflow } 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';\n\nconst WORKFLOW_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.Workflow');\n\n/**\n * Represents the latest version of a workflow. When using the workflow in a pipeline, the pipeline will use the\n * latest workflow at the time of execution.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html\n */\nconst LATEST_VERSION = 'x.x.x';\n\n/**\n * An EC2 Image Builder Workflow.\n */\nexport interface IWorkflow extends cdk.IResource {\n  /**\n   * The ARN of the workflow\n   *\n   * @attribute\n   */\n  readonly workflowArn: string;\n\n  /**\n   * The name of the workflow\n   *\n   * @attribute\n   */\n  readonly workflowName: string;\n\n  /**\n   * The type of the workflow\n   *\n   * @attribute\n   */\n  readonly workflowType: string;\n\n  /**\n   * The version of the workflow\n   *\n   * @attribute\n   */\n  readonly workflowVersion: string;\n\n  /**\n   * Grant custom actions to the given grantee for the workflow\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 workflow\n   *\n   * @param grantee The principal\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Properties for creating a Workflow resource\n */\nexport interface WorkflowProps {\n  /**\n   * The workflow document content that defines the image creation process.\n   */\n  readonly data: WorkflowData;\n\n  /**\n   * The phase in the image build process for which the workflow resource is responsible.\n   */\n  readonly workflowType: WorkflowType;\n\n  /**\n   * The name of the workflow.\n   *\n   * @default - a name is generated\n   */\n  readonly workflowName?: string;\n\n  /**\n   * The version of the workflow.\n   *\n   * @default 1.0.0\n   */\n  readonly workflowVersion?: string;\n\n  /**\n   * The description of the workflow.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The change description of the workflow. Describes what change has been made in this version of the workflow, 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 workflow.\n   *\n   * @default - an Image Builder owned key will be used to encrypt the workflow.\n   */\n  readonly kmsKey?: kms.IKey;\n\n  /**\n   * The tags to apply to the workflow\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Properties for an EC2 Image Builder Workflow\n */\nexport interface WorkflowAttributes {\n  /**\n   * The ARN of the workflow\n   *\n   * @default - the ARN is automatically constructed if a workflowName and workflowType is provided, otherwise a\n   * workflowArn is required\n   */\n  readonly workflowArn?: string;\n\n  /**\n   * The name of the workflow\n   *\n   * @default - the name is automatically constructed if a workflowArn is provided, otherwise a workflowName is required\n   */\n  readonly workflowName?: string;\n\n  /**\n   * The type of the workflow\n   *\n   * @default - the type is automatically constructed if a workflowArn is provided, otherwise a workflowType is required\n   */\n  readonly workflowType?: WorkflowType;\n\n  /**\n   * The version of the workflow\n   *\n   * @default x.x.x\n   */\n  readonly workflowVersion?: string;\n}\n\n/**\n * Properties for an EC2 Image Builder AWS-managed workflow\n */\nexport interface AwsManagedWorkflowAttributes {\n  /**\n   * The name of the AWS-managed workflow\n   */\n  readonly workflowName: string;\n\n  /**\n   * The type of the AWS-managed workflow\n   */\n  readonly workflowType: WorkflowType;\n}\n\n/**\n * The action for a step within the workflow document\n */\nexport enum WorkflowAction {\n  /**\n   * Applies customizations and configurations to the input AMIs, such as publishing the AMI to SSM Parameter Store,\n   * or creating launch template versions with the AMI IDs provided in the input\n   */\n  APPLY_IMAGE_CONFIGURATIONS = 'ApplyImageConfigurations',\n\n  /**\n   * The BootstrapInstanceForContainer action runs a service script to bootstrap the instance with minimum requirements\n   * to run container workflows\n   */\n  BOOTSTRAP_INSTANCE_FOR_CONTAINER = 'BootstrapInstanceForContainer',\n\n  /**\n   * The CollectImageMetadata action collects additional information about the instance, such as the list of packages\n   * and their respective versions\n   */\n  COLLECT_IMAGE_METADATA = 'CollectImageMetadata',\n\n  /**\n   * The CollectImageScanFindings action collects findings reported by Amazon Inspector for the provided instance\n   */\n  COLLECT_IMAGE_SCAN_FINDINGS = 'CollectImageScanFindings',\n\n  /**\n   * The CreateImage action creates an AMI from a running instance with the ec2:CreateImage API\n   */\n  CREATE_IMAGE = 'CreateImage',\n\n  /**\n   * The DistributeImage action copies an AMI using the image's distribution configuration, or using the distribution\n   * settings in the step input\n   */\n  DISTRIBUTE_IMAGE = 'DistributeImage',\n\n  /**\n   * The ExecuteComponents action runs components that are specified in the recipe for the current image being built\n   */\n  EXECUTE_COMPONENTS = 'ExecuteComponents',\n\n  /**\n   * The ExecuteStateMachine action executes a the state machine provided and waits for completion as part of the\n   * workflow\n   */\n  EXECUTE_STATE_MACHINE = 'ExecuteStateMachine',\n\n  /**\n   * The LaunchInstance action launches an instance using the settings from your recipe and infrastructure configuration\n   * resources\n   */\n  LAUNCH_INSTANCE = 'LaunchInstance',\n\n  /**\n   * Applies attribute updates to the provided set of distributed images, such as launch permission updates\n   */\n  MODIFY_IMAGE_ATTRIBUTES = 'ModifyImageAttributes',\n\n  /**\n   * The RunCommand action runs a command document against the provided instance\n   */\n  RUN_COMMAND = 'RunCommand',\n\n  /**\n   * The RegisterImage action creates an AMI from a set of snapshots with the ec2:RegisterImage API\n   */\n  REGISTER_IMAGE = 'RegisterImage',\n\n  /**\n   * The RunSysprep action runs the Sysprep document on the provided Windows instance\n   */\n  RUN_SYS_PREP = 'RunSysPrep',\n\n  /**\n   * The SanitizeInstance action runs a recommended sanitization script on Linux instances\n   */\n  SANITIZE_INSTANCE = 'SanitizeInstance',\n\n  /**\n   * The TerminateInstance action terminates the provided instance\n   */\n  TERMINATE_INSTANCE = 'TerminateInstance',\n\n  /**\n   * The WaitForAction action pauses the workflow and waits to receive an external signal from the\n   * imagebuilder:SendWorkflowStepAction API\n   */\n  WAIT_FOR_ACTION = 'WaitForAction',\n\n  /**\n   * The WaitForSSMAgent action waits for the given instance to have connectivity with SSM before proceeding\n   */\n  WAIT_FOR_SSM_AGENT = 'WaitForSSMAgent',\n}\n\n/**\n * The action to take if the workflow fails\n */\nexport enum WorkflowOnFailure {\n  /**\n   * Fails the image build if the workflow fails\n   */\n  ABORT = 'Abort',\n\n  /**\n   * Continues with the image build if the workflow fails\n   */\n  CONTINUE = 'Continue',\n}\n\n/**\n * The parameter type for the workflow parameter\n */\nexport enum WorkflowParameterType {\n  /**\n   * Indicates the workflow parameter has a boolean value\n   */\n  BOOLEAN = 'boolean',\n\n  /**\n   * Indicates the workflow parameter has an integer value\n   */\n  INTEGER = 'integer',\n\n  /**\n   * Indicates the workflow parameter has a string value\n   */\n  STRING = 'string',\n\n  /**\n   * Indicates the workflow parameter has a string list value\n   */\n  STRING_LIST = 'stringList',\n}\n\n/**\n * The schema version of the workflow\n */\nexport enum WorkflowSchemaVersion {\n  /**\n   * Schema version 1.0 for the workflow document\n   */\n  V1_0 = '1.0',\n}\n\n/**\n * The type of the workflow\n */\nexport enum WorkflowType {\n  /**\n   * Indicates the workflow is for building images\n   */\n  BUILD = 'BUILD',\n\n  /**\n   * Indicates the workflow is for testing images\n   */\n  TEST = 'TEST',\n\n  /**\n   * Indicates the workflow is for distributing images\n   */\n  DISTRIBUTION = 'DISTRIBUTION',\n}\n\n/**\n * The rendered workflow data value, for use in CloudFormation.\n * - For inline workflows, data is the workflow text\n * - For S3-backed workflows, uri is the S3 URL\n */\nexport interface WorkflowDataConfig {\n  /**\n   * The rendered workflow data, for use in CloudFormation\n   *\n   * @default - none if uri is set\n   */\n  readonly data?: string;\n\n  /**\n   * The rendered workflow data URI, for use in CloudFormation\n   *\n   * @default - none if data is set\n   */\n  readonly uri?: string;\n}\n\n/**\n * Helper class for referencing and uploading workflow data\n */\nexport abstract class WorkflowData {\n  /**\n   * Uploads workflow data from a local file to S3 to use as the workflow data\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param path The local path to the workflow 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  ): S3WorkflowData {\n    const asset = new s3assets.Asset(scope, id, { ...options, path });\n    return new S3WorkflowDataFromAsset(asset);\n  }\n\n  /**\n   * References workflow data from a pre-existing S3 object\n   *\n   * @param bucket The S3 bucket where the workflow data is stored\n   * @param key The S3 key of the workflow data file\n   */\n  public static fromS3(bucket: s3.IBucket, key: string): S3WorkflowData {\n    return new S3WorkflowDataFromBucketKey(bucket, key);\n  }\n\n  /**\n   * Uses an inline JSON object as the workflow data\n   *\n   * @param data An inline JSON object representing the workflow data\n   */\n  public static fromJsonObject(data: { [key: string]: any }): WorkflowData {\n    const inlineData = yaml.stringify(data, { indent: 2 });\n    return new InlineWorkflowData(inlineData);\n  }\n\n  /**\n   * Uses an inline JSON or YAML string as the workflow data\n   *\n   * @param data An inline JSON or YAML string representing the workflow data\n   */\n  public static fromInline(data: string): WorkflowData {\n    return new InlineWorkflowData(data);\n  }\n\n  /**\n   * The rendered workflow data value, for use in CloudFormation.\n   * - For inline workflows, data is the workflow text\n   * - For S3-backed workflows, uri is the S3 URL\n   */\n  abstract render(): WorkflowDataConfig;\n}\n\n/**\n * Helper class for S3-based workflow data references, containing additional permission grant methods on the S3 object\n */\nexport abstract class S3WorkflowData extends WorkflowData {\n  protected readonly bucket: s3.IBucket;\n  protected readonly key: string;\n\n  protected constructor(bucket: s3.IBucket, key: string) {\n    super();\n\n    this.bucket = bucket;\n    this.key = key;\n  }\n\n  /**\n   * The rendered workflow data text, for use in CloudFormation\n   */\n  public render(): WorkflowDataConfig {\n    return { uri: this.bucket.s3UrlForObject(this.key) };\n  }\n\n  /**\n   * Grant put permissions to the given grantee for the workflow 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 workflow 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 InlineWorkflowData extends WorkflowData {\n  protected readonly data: string;\n\n  public constructor(data: string) {\n    super();\n\n    this.data = data;\n  }\n\n  /**\n   * The rendered workflow data text, for use in CloudFormation\n   */\n  public render(): WorkflowDataConfig {\n    return { data: this.data };\n  }\n}\n\nclass S3WorkflowDataFromBucketKey extends S3WorkflowData {\n  public constructor(bucket: s3.IBucket, key: string) {\n    super(bucket, key);\n  }\n}\n\nclass S3WorkflowDataFromAsset extends S3WorkflowData {\n  public constructor(asset: s3assets.Asset) {\n    super(asset.bucket, asset.s3ObjectKey);\n  }\n}\n\n/**\n * Helper class for working with AWS-managed workflows\n */\nexport class AwsManagedWorkflow {\n  /**\n   * Imports the build-container AWS-managed workflow\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   */\n  public static buildContainer(scope: Construct, id: string): IWorkflow {\n    return this.fromAwsManagedWorkflowAttributes(scope, id, {\n      workflowName: 'build-container',\n      workflowType: WorkflowType.BUILD,\n    });\n  }\n\n  /**\n   * Imports the build-image AWS-managed workflow\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   */\n  public static buildImage(scope: Construct, id: string): IWorkflow {\n    return this.fromAwsManagedWorkflowAttributes(scope, id, {\n      workflowName: 'build-image',\n      workflowType: WorkflowType.BUILD,\n    });\n  }\n\n  /**\n   * Imports the distribute-container AWS-managed workflow\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   */\n  public static distributeContainer(scope: Construct, id: string): IWorkflow {\n    return this.fromAwsManagedWorkflowAttributes(scope, id, {\n      workflowName: 'distribute-container',\n      workflowType: WorkflowType.DISTRIBUTION,\n    });\n  }\n\n  /**\n   * Imports the test-container AWS-managed workflow\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   */\n  public static testContainer(scope: Construct, id: string): IWorkflow {\n    return this.fromAwsManagedWorkflowAttributes(scope, id, {\n      workflowName: 'test-container',\n      workflowType: WorkflowType.TEST,\n    });\n  }\n\n  /**\n   * Imports the test-image AWS-managed workflow\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   */\n  public static testImage(scope: Construct, id: string): IWorkflow {\n    return this.fromAwsManagedWorkflowAttributes(scope, id, {\n      workflowName: 'test-image',\n      workflowType: WorkflowType.TEST,\n    });\n  }\n\n  /**\n   * Imports an AWS-managed workflow from its attributes\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param attrs The attributes of the AWS-managed workflow\n   */\n  public static fromAwsManagedWorkflowAttributes(\n    scope: Construct,\n    id: string,\n    attrs: AwsManagedWorkflowAttributes,\n  ): IWorkflow {\n    if (cdk.Token.isUnresolved(attrs.workflowType)) {\n      throw new cdk.ValidationError('workflowType cannot be a token', scope);\n    }\n\n    return Workflow.fromWorkflowArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        account: 'aws',\n        resource: 'workflow',\n        resourceName: `${attrs.workflowType.toLowerCase()}/${attrs.workflowName}/${LATEST_VERSION}`,\n      }),\n    );\n  }\n}\n\n/**\n * A new or imported Workflow\n */\nabstract class WorkflowBase extends cdk.Resource implements IWorkflow {\n  /**\n   * The ARN of the workflow\n   */\n  abstract readonly workflowArn: string;\n\n  /**\n   * The name of the workflow\n   */\n  abstract readonly workflowName: string;\n\n  /**\n   * The type of the workflow\n   */\n  abstract readonly workflowType: string;\n\n  /**\n   * The version of the workflow\n   */\n  abstract readonly workflowVersion: string;\n\n  /**\n   * Grant custom actions to the given grantee for the workflow\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.workflowArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the workflow\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetWorkflow');\n  }\n}\n\n/**\n * Represents an EC2 Image Builder Workflow.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-image-workflows.html\n */\n@propertyInjectable\nexport class Workflow extends WorkflowBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.Workflow';\n\n  /**\n   * Import an existing workflow given its ARN.\n   */\n  public static fromWorkflowArn(scope: Construct, id: string, workflowArn: string): IWorkflow {\n    return this.fromWorkflowAttributes(scope, id, { workflowArn });\n  }\n\n  /**\n   * Import an existing workflow by providing its attributes. The provided name must be normalized by converting\n   * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens. You may not\n   * provide a dynamic expression for the workflowArn or workflowType\n   */\n  public static fromWorkflowAttributes(scope: Construct, id: string, attrs: WorkflowAttributes): IWorkflow {\n    if (\n      attrs.workflowArn !== undefined &&\n      (attrs.workflowName !== undefined || attrs.workflowType !== undefined || attrs.workflowVersion !== undefined)\n    ) {\n      throw new cdk.ValidationError(\n        'a workflowName, workflowType, or workflowVersion cannot be provided when a workflowArn is provided',\n        scope,\n      );\n    }\n\n    if (attrs.workflowArn === undefined && (attrs.workflowName === undefined || attrs.workflowType === undefined)) {\n      throw new cdk.ValidationError('either workflowArn, or workflowName and workflowType is required', scope);\n    }\n\n    if (attrs.workflowType && cdk.Token.isUnresolved(attrs.workflowType)) {\n      throw new cdk.ValidationError('workflowType cannot be an unresolved token', scope);\n    }\n\n    const workflowArn = (() => {\n      if (attrs.workflowArn !== undefined) {\n        return attrs.workflowArn;\n      }\n\n      return cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'workflow',\n        resourceName: `${attrs.workflowType!.toLowerCase()}/${attrs.workflowName!}/${attrs.workflowVersion ?? LATEST_VERSION}`,\n      });\n    })();\n\n    const [workflowType, workflowName, workflowVersion] = (() => {\n      if (attrs.workflowName !== undefined) {\n        return [attrs.workflowType!.toUpperCase(), attrs.workflowName, attrs.workflowVersion ?? LATEST_VERSION];\n      }\n\n      const workflowNameTypeVersion = cdk.Stack.of(scope).splitArn(\n        workflowArn,\n        cdk.ArnFormat.SLASH_RESOURCE_NAME,\n      ).resourceName!;\n\n      if (cdk.Token.isUnresolved(workflowNameTypeVersion)) {\n        throw new cdk.ValidationError(\n          'the workflowName, workflowType, and workflowVersion in the workflowArn cannot be an unresolved token',\n          scope,\n        );\n      }\n\n      if (workflowNameTypeVersion.split('/').length < 3) {\n        throw new cdk.ValidationError(\n          'the workflow ARN must end with <workflow-type>/<workflow-name>/<workflow-version>',\n          scope,\n        );\n      }\n\n      const workflowNameTypeVersionSplit = workflowNameTypeVersion.split('/');\n      const [workflowTypeFromArn, workflowNameFromArn, workflowVersionFromArn] = workflowNameTypeVersionSplit.slice(\n        0,\n        3,\n      );\n\n      return [workflowTypeFromArn.toUpperCase(), workflowNameFromArn, workflowVersionFromArn];\n    })();\n\n    class Import extends WorkflowBase {\n      public readonly workflowArn = workflowArn;\n      public readonly workflowName = workflowName;\n      public readonly workflowType = workflowType;\n      public readonly workflowVersion = workflowVersion;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Return whether the given object is a Workflow.\n   */\n  public static isWorkflow(x: any): x is Workflow {\n    return x !== null && typeof x === 'object' && WORKFLOW_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the workflow\n   */\n  public readonly workflowArn: string;\n\n  /**\n   * The name of the workflow\n   */\n  public readonly workflowName: string;\n\n  /**\n   * The type of the workflow\n   */\n  public readonly workflowType: string;\n\n  /**\n   * The version of the workflow\n   */\n  public readonly workflowVersion: string;\n\n  public constructor(scope: Construct, id: string, props: WorkflowProps) {\n    super(scope, id, {\n      physicalName:\n        props.workflowName ??\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, WORKFLOW_SYMBOL, { value: true });\n\n    this.validateWorkflowName();\n\n    const workflowVersion = props.workflowVersion ?? '1.0.0';\n    const workflow = new CfnWorkflow(this, 'Resource', {\n      name: this.physicalName,\n      version: workflowVersion,\n      type: props.workflowType,\n      changeDescription: props.changeDescription,\n      description: props.description,\n      kmsKeyId: props.kmsKey?.keyArn,\n      tags: props.tags,\n      ...props.data.render(),\n    });\n\n    this.workflowName = this.getResourceNameAttribute(workflow.getAtt('Name').toString());\n    this.workflowArn = workflow.attrArn;\n    this.workflowVersion = workflowVersion;\n    this.workflowType = props.workflowType;\n  }\n\n  private validateWorkflowName() {\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('the workflowName cannot be longer than 128 characters', this);\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError('the workflowName cannot contain spaces', this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError('the workflowName cannot contain underscores', this);\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError('the workflowName must be lowercase', this);\n    }\n  }\n}\n"]}