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

package/lib/lifecycle-policy.js

@@ -0,0 +1,459 @@
+"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.LifecyclePolicy = exports.LifecyclePolicyResourceType = exports.LifecyclePolicyStatus = exports.LifecyclePolicyActionType = 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 metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const LIFECYCLE_POLICY_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.LifecyclePolicy');
+/**
+ * The action to perform on the resources which the policy applies to
+ */
+var LifecyclePolicyActionType;
+(function (LifecyclePolicyActionType) {
+    /**
+     * Indicates that the rule should delete the resource when it is applied
+     */
+    LifecyclePolicyActionType["DELETE"] = "DELETE";
+    /**
+     * Indicates that the rule should deprecate the resource when it is applied
+     */
+    LifecyclePolicyActionType["DEPRECATE"] = "DEPRECATE";
+    /**
+     * Indicates that the rule should disable the resource when it is applied
+     */
+    LifecyclePolicyActionType["DISABLE"] = "DISABLE";
+})(LifecyclePolicyActionType || (exports.LifecyclePolicyActionType = LifecyclePolicyActionType = {}));
+/**
+ * The status of the lifecycle policy, indicating whether it will run
+ */
+var LifecyclePolicyStatus;
+(function (LifecyclePolicyStatus) {
+    /**
+     * Indicates that the lifecycle policy should be enabled
+     */
+    LifecyclePolicyStatus["ENABLED"] = "ENABLED";
+    /**
+     * Indicates that the lifecycle policy should be disabled
+     */
+    LifecyclePolicyStatus["DISABLED"] = "DISABLED";
+})(LifecyclePolicyStatus || (exports.LifecyclePolicyStatus = LifecyclePolicyStatus = {}));
+/**
+ * The resource type which the lifecycle policy is applied to
+ */
+var LifecyclePolicyResourceType;
+(function (LifecyclePolicyResourceType) {
+    /**
+     * Indicates the policy applies to AMI-based images
+     */
+    LifecyclePolicyResourceType["AMI_IMAGE"] = "AMI_IMAGE";
+    /**
+     * Indicates the policy applies to container images
+     */
+    LifecyclePolicyResourceType["CONTAINER_IMAGE"] = "CONTAINER_IMAGE";
+})(LifecyclePolicyResourceType || (exports.LifecyclePolicyResourceType = LifecyclePolicyResourceType = {}));
+class LifecyclePolicyBase extends cdk.Resource {
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.lifecyclePolicyArn],
+            scope: this,
+        });
+    }
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetLifecyclePolicy');
+    }
+}
+/**
+ * Represents an EC2 Image Builder Lifecycle Policy.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-image-lifecycles.html
+ */
+let LifecyclePolicy = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = LifecyclePolicyBase;
+    var LifecyclePolicy = 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);
+            LifecyclePolicy = _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.LifecyclePolicy", version: "2.231.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.LifecyclePolicy';
+        /**
+         * Import an existing lifecycle policy given its ARN.
+         */
+        static fromLifecyclePolicyArn(scope, id, lifecyclePolicyArn) {
+            const lifecyclePolicyName = cdk.Stack.of(scope).splitArn(lifecyclePolicyArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+            class Import extends LifecyclePolicyBase {
+                lifecyclePolicyArn = lifecyclePolicyArn;
+                lifecyclePolicyName = lifecyclePolicyName;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Import an existing lifecycle policy given its name. If the name is a token representing a dynamic CloudFormation
+         * expression, you must ensure all alphabetic characters in the expression are already lowercased
+         */
+        static fromLifecyclePolicyName(scope, id, lifecyclePolicyName) {
+            return LifecyclePolicy.fromLifecyclePolicyArn(scope, id, cdk.Stack.of(scope).formatArn({
+                service: 'imagebuilder',
+                resource: 'lifecycle-policy',
+                resourceName: lifecyclePolicyName,
+            }));
+        }
+        /**
+         * Return whether the given object is a LifecyclePolicy.
+         */
+        static isLifecyclePolicy(x) {
+            return x !== null && typeof x === 'object' && LIFECYCLE_POLICY_SYMBOL in x;
+        }
+        /**
+         * The ARN of the lifecycle policy
+         */
+        lifecyclePolicyArn;
+        /**
+         * The name of the lifecycle policy
+         */
+        lifecyclePolicyName;
+        /**
+         * The execution role used for lifecycle policy executions
+         */
+        executionRole;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.lifecyclePolicyName ??
+                    cdk.Lazy.string({
+                        produce: () => cdk.Names.uniqueResourceName(this, {
+                            maxLength: 128,
+                            separator: '-',
+                            allowedSpecialCharacters: '-',
+                        }).toLowerCase(),
+                    }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_LifecyclePolicyProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, LifecyclePolicy);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, LIFECYCLE_POLICY_SYMBOL, { value: true });
+            this.validateLifecyclePolicyName();
+            this.validatePolicy(props);
+            this.executionRole =
+                props.executionRole ??
+                    new iam.Role(this, 'ExecutionRole', {
+                        assumedBy: new iam.ServicePrincipal('imagebuilder.amazonaws.com'),
+                        managedPolicies: [
+                            iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/EC2ImageBuilderLifecycleExecutionPolicy'),
+                        ],
+                    });
+            const lifecyclePolicy = new aws_imagebuilder_1.CfnLifecyclePolicy(this, 'Resource', {
+                name: this.physicalName,
+                description: props.description,
+                resourceType: props.resourceType,
+                executionRole: this.executionRole.roleArn,
+                policyDetails: this.buildPolicyDetails(props.resourceType, props.details),
+                resourceSelection: {
+                    ...(props.resourceSelection.recipes !== undefined && {
+                        recipes: this.buildRecipes(props.resourceType, props.resourceSelection.recipes),
+                    }),
+                    tagMap: props.resourceSelection.tags,
+                },
+                status: props.status,
+                tags: props.tags,
+            });
+            this.lifecyclePolicyName = this.getResourceNameAttribute(lifecyclePolicy.ref);
+            this.lifecyclePolicyArn = this.getResourceArnAttribute(lifecyclePolicy.attrArn, {
+                service: 'imagebuilder',
+                resource: 'lifecycle-policy',
+                resourceName: this.physicalName,
+            });
+        }
+        /**
+         * Generates the policy details property into the `PolicyDetail` type in the CloudFormation L1 definition.
+         *
+         * @param resourceType The resource type of the lifecycle policy
+         * @param details The lifecycle policy rules
+         * @private
+         */
+        buildPolicyDetails(resourceType, details) {
+            return details.map((detail) => {
+                const action = this.buildAction(resourceType, detail.action);
+                const exclusionRules = detail.exclusionRules !== undefined ? this.buildExclusionRules(detail.exclusionRules) : undefined;
+                this.validatePolicyDetailAction(resourceType, detail.action, exclusionRules?.amis);
+                this.validatePolicyDetailFilter(detail.filter);
+                return {
+                    action: action,
+                    filter: {
+                        retainAtLeast: detail.filter.ageFilter?.retainAtLeast,
+                        type: detail.filter.ageFilter !== undefined ? 'AGE' : 'COUNT',
+                        ...(detail.filter.ageFilter !== undefined
+                            ? this.convertDurationToTimeUnitValue(detail.filter.ageFilter.age)
+                            : { value: detail.filter.countFilter.count }),
+                    },
+                    ...(exclusionRules !== undefined && { exclusionRules }),
+                };
+            });
+        }
+        /**
+         * Generates the recipes property in the resource selection into the `RecipeSelection` type in the CloudFormation L1
+         * definition.
+         *
+         * @param resourceType The resource type of the lifecycle policy
+         * @param recipes The recipes passed in the props
+         * @private
+         */
+        buildRecipes(resourceType, recipes) {
+            return recipes?.map((recipe) => {
+                if (recipe._isImageRecipe()) {
+                    if (resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE) {
+                        throw new cdk.ValidationError(`recipes in the resource selection must all be container recipes for policy type ${LifecyclePolicyResourceType.CONTAINER_IMAGE}`, this);
+                    }
+                    return {
+                        name: recipe.imageRecipeName,
+                        semanticVersion: recipe.imageRecipeVersion,
+                    };
+                }
+                if (recipe._isContainerRecipe()) {
+                    if (resourceType === LifecyclePolicyResourceType.AMI_IMAGE) {
+                        throw new cdk.ValidationError(`recipes in the resource selection must all be image recipes for policy type ${LifecyclePolicyResourceType.AMI_IMAGE}`, this);
+                    }
+                    return {
+                        name: recipe.containerRecipeName,
+                        semanticVersion: recipe.containerRecipeVersion,
+                    };
+                }
+                throw new cdk.ValidationError('recipes in the resource selection must either be an IImageRecipe or IContainerRecipe', this);
+            });
+        }
+        /**
+         * Generates the exclusion rules property into the `ExclusionRules` type in the CloudFormation L1 definition.
+         *
+         * @param exclusionRules The exclusion rules for resources applied in the lifecycle policy rule
+         * @private
+         */
+        buildExclusionRules(exclusionRules) {
+            const amiExclusionRules = {
+                ...(exclusionRules.amiExclusionRules?.isPublic && { isPublic: exclusionRules.amiExclusionRules.isPublic }),
+                ...(exclusionRules.amiExclusionRules?.lastLaunched !== undefined && {
+                    lastLaunched: this.convertDurationToTimeUnitValue(exclusionRules.amiExclusionRules.lastLaunched, 365),
+                }),
+                ...(exclusionRules.amiExclusionRules?.regions?.length && { regions: exclusionRules.amiExclusionRules.regions }),
+                ...(exclusionRules.amiExclusionRules?.sharedAccounts?.length && {
+                    sharedAccounts: exclusionRules.amiExclusionRules.sharedAccounts,
+                }),
+                ...(exclusionRules.amiExclusionRules?.tags && { tagMap: exclusionRules.amiExclusionRules.tags }),
+            };
+            const cfnExclusionRules = {
+                ...(Object.keys(amiExclusionRules).length && { amis: amiExclusionRules }),
+                ...(exclusionRules.imageExclusionRules !== undefined && { tagMap: exclusionRules.imageExclusionRules.tags }),
+            };
+            return Object.keys(exclusionRules).length ? cfnExclusionRules : undefined;
+        }
+        /**
+         * Generates the action property into the `Action` type in the CloudFormation L1 definition.
+         *
+         * @param resourceType The resource type of the lifecycle policy
+         * @param action The action being taken in the lifecycle policy rule
+         * @private
+         */
+        buildAction(resourceType, action) {
+            const isContainerPolicy = !cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE;
+            const isAmiPolicy = !cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.AMI_IMAGE;
+            const amis = action.includeAmis ?? (isAmiPolicy ? true : undefined);
+            const snapshots = action.includeSnapshots ?? (isAmiPolicy ? true : undefined);
+            const containers = action.includeContainers ?? (isContainerPolicy ? true : undefined);
+            const includeResources = {
+                ...(amis !== undefined && { amis }),
+                ...(snapshots !== undefined && { snapshots }),
+                ...(containers !== undefined && { containers }),
+            };
+            return {
+                type: action.type,
+                ...(Object.keys(includeResources).length && { includeResources }),
+            };
+        }
+        /**
+         * Validates the top-level properties of the policy
+         *
+         * @param props The props passed as input to the construct
+         * @private
+         */
+        validatePolicy(props) {
+            if (props.resourceSelection.recipes?.length && Object.keys(props.resourceSelection.tags || {}).length) {
+                throw new cdk.ValidationError('resource selection cannot contain both recipes and tags', this);
+            }
+            if (!props.resourceSelection.recipes?.length && !Object.keys(props.resourceSelection.tags || {}).length) {
+                throw new cdk.ValidationError('resource selection must contain either recipes or tags', this);
+            }
+            if (props.details.length === 0) {
+                throw new cdk.ValidationError('a lifecycle policy must have at least 1 rule', this);
+            }
+            if (props.details.length > 3) {
+                throw new cdk.ValidationError('a lifecycle policy can only have up to 3 rules', this);
+            }
+            const actions = props.details.map((detail) => detail.action.type);
+            if (new Set(actions).size != actions.length) {
+                throw new cdk.ValidationError('lifecycle policy rules may not have duplicate actions', this);
+            }
+        }
+        /**
+         * Validates a policy detail filter within a lifecycle policy rule
+         *
+         * @param resourceType The resource type of the lifecycle policy
+         * @param action The action being taken in the lifecycle policy rule
+         * @param amiExclusionRules The AMI exclusion rules in the lifecycle policy rule
+         * @private
+         */
+        validatePolicyDetailAction(resourceType, action, amiExclusionRules) {
+            if (!cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE) {
+                if (!cdk.Token.isUnresolved(action.type) && action.type !== LifecyclePolicyActionType.DELETE) {
+                    throw new cdk.ValidationError('you may only specify DELETE rules for container policies', this);
+                }
+                if (action.includeAmis) {
+                    throw new cdk.ValidationError('you cannot include AMIs in a container policy', this);
+                }
+                if (action.includeSnapshots) {
+                    throw new cdk.ValidationError('you cannot include snapshots in a container policy', this);
+                }
+                if (amiExclusionRules !== undefined) {
+                    throw new cdk.ValidationError('you cannot exclude AMIs in a container policy', this);
+                }
+            }
+            if (!cdk.Token.isUnresolved(resourceType) &&
+                resourceType === LifecyclePolicyResourceType.AMI_IMAGE &&
+                action.includeContainers) {
+                throw new cdk.ValidationError('you cannot include containers in an AMI policy', this);
+            }
+        }
+        /**
+         * Validates a policy detail filter
+         *
+         * @param filter The lifecycle policy resource filter applied in the rule
+         * @private
+         */
+        validatePolicyDetailFilter(filter) {
+            if (filter.ageFilter !== undefined && filter.countFilter !== undefined) {
+                throw new cdk.ValidationError('either age count can be specified in a policy filter, but not both', this);
+            }
+            if (filter.ageFilter === undefined && filter.countFilter === undefined) {
+                throw new cdk.ValidationError('you must provide an age or count filter in the policy', this);
+            }
+            const retainAtLeast = filter.ageFilter?.retainAtLeast;
+            if (retainAtLeast !== undefined) {
+                if (retainAtLeast < 1) {
+                    throw new cdk.ValidationError('the retainAtLeast filter value must be at least 1', this);
+                }
+                if (retainAtLeast > 10) {
+                    throw new cdk.ValidationError('the retainAtLeast filter value must be at most 10', this);
+                }
+            }
+        }
+        /**
+         * Converts a `cdk.Duration` into the value and unit which is accepted as filter age and last launched age in the
+         * lifecycle policy. The value is rounded up to the nearest whole number.
+         *
+         * @param duration The duration to convert
+         * @param valueLimit The maximum value that can be specified
+         * @private
+         */
+        convertDurationToTimeUnitValue(duration, valueLimit = 1000) {
+            const DAYS_PER_WEEK = 7;
+            const DAYS_PER_MONTH = 30;
+            const DAYS_PER_YEAR = 365;
+            const valueInDays = Math.ceil(duration.toDays());
+            if (valueInDays < 1) {
+                throw new cdk.ValidationError('the provided duration must be at least 1 day', this);
+            }
+            if (valueInDays <= valueLimit) {
+                return { value: valueInDays, unit: 'DAYS' };
+            }
+            const valueInWeeks = Math.ceil(valueInDays / DAYS_PER_WEEK);
+            if (valueInWeeks <= valueLimit) {
+                return { value: valueInWeeks, unit: 'WEEKS' };
+            }
+            const valueInMonths = Math.ceil(valueInDays / DAYS_PER_MONTH);
+            if (valueInMonths <= valueLimit) {
+                return { value: valueInMonths, unit: 'MONTHS' };
+            }
+            const valueInYears = Math.ceil(valueInDays / DAYS_PER_YEAR);
+            if (valueInYears <= valueLimit) {
+                return { value: valueInYears, unit: 'YEARS' };
+            }
+            throw new cdk.ValidationError(`the provided duration must be less than ${valueLimit} years`, this);
+        }
+        validateLifecyclePolicyName() {
+            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 lifecyclePolicyName cannot be longer than 128 characters', this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError('The lifecyclePolicyName cannot contain spaces', this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError('The lifecyclePolicyName cannot contain underscores', this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError('The lifecyclePolicyName must be lowercase', this);
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return LifecyclePolicy = _classThis;
+})();
+exports.LifecyclePolicy = LifecyclePolicy;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifecycle-policy.js","sourceRoot":"","sources":["lifecycle-policy.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 { CfnLifecyclePolicy } from 'aws-cdk-lib/aws-imagebuilder';\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 { IRecipeBase } from './recipe-base';\n\nconst LIFECYCLE_POLICY_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.LifecyclePolicy');\n\n/**\n * An EC2 Image Builder Lifecycle Policy.\n */\nexport interface ILifecyclePolicy extends cdk.IResource {\n  /**\n   * The ARN of the lifecycle policy\n   *\n   * @attribute\n   */\n  readonly lifecyclePolicyArn: string;\n\n  /**\n   * The name of the lifecycle policy\n   *\n   * @attribute\n   */\n  readonly lifecyclePolicyName: string;\n\n  /**\n   * Grant custom actions to the given grantee for the lifecycle policy\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 lifecycle policy\n   *\n   * @param grantee - The principal\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * The action to perform on the resources which the policy applies to\n */\nexport enum LifecyclePolicyActionType {\n  /**\n   * Indicates that the rule should delete the resource when it is applied\n   */\n  DELETE = 'DELETE',\n  /**\n   * Indicates that the rule should deprecate the resource when it is applied\n   */\n  DEPRECATE = 'DEPRECATE',\n  /**\n   * Indicates that the rule should disable the resource when it is applied\n   */\n  DISABLE = 'DISABLE',\n}\n\n/**\n * The status of the lifecycle policy, indicating whether it will run\n */\nexport enum LifecyclePolicyStatus {\n  /**\n   * Indicates that the lifecycle policy should be enabled\n   */\n  ENABLED = 'ENABLED',\n\n  /**\n   * Indicates that the lifecycle policy should be disabled\n   */\n  DISABLED = 'DISABLED',\n}\n\n/**\n * The resource type which the lifecycle policy is applied to\n */\nexport enum LifecyclePolicyResourceType {\n  /**\n   * Indicates the policy applies to AMI-based images\n   */\n  AMI_IMAGE = 'AMI_IMAGE',\n\n  /**\n   * Indicates the policy applies to container images\n   */\n  CONTAINER_IMAGE = 'CONTAINER_IMAGE',\n}\n\n/**\n * The action to perform in the lifecycle policy rule\n */\nexport interface LifecyclePolicyAction {\n  /**\n   * The action to perform on the resources selected in the lifecycle policy rule\n   */\n  readonly type: LifecyclePolicyActionType;\n\n  /**\n   * Whether to include AMIs in the scope of the lifecycle rule\n   *\n   * @default - true for AMI-based policies, false otherwise\n   */\n  readonly includeAmis?: boolean;\n\n  /**\n   * Whether to include containers in the scope of the lifecycle rule\n   *\n   * @default - true for container-based policies, false otherwise\n   */\n  readonly includeContainers?: boolean;\n\n  /**\n   * Whether to include snapshots in the scope of the lifecycle rule\n   *\n   * @default - true for AMI-based policies, false otherwise\n   */\n  readonly includeSnapshots?: boolean;\n}\n\n/**\n * The resource filtering to apply in the lifecycle policy rule\n */\nexport interface LifecyclePolicyFilter {\n  /**\n   * The resource age filter to apply in the lifecycle policy rule\n   *\n   * @default - none if a count filter is provided. Otherwise, an age filter is required.\n   */\n  readonly ageFilter?: LifecyclePolicyAgeFilter;\n\n  /**\n   * The resource count filter to apply in the lifecycle policy rule\n   *\n   * @default - none if an age filter is provided. Otherwise, a count filter is required.\n   */\n  readonly countFilter?: LifecyclePolicyCountFilter;\n}\n\n/**\n * The count-based filtering to apply in a lifecycle policy rule\n */\nexport interface LifecyclePolicyCountFilter {\n  /**\n   * The minimum number of resources to keep on hand as part of resource filtering\n   */\n  readonly count: number;\n}\n\n/**\n * The age-based filtering to apply in a lifecycle policy rule\n */\nexport interface LifecyclePolicyAgeFilter {\n  /**\n   * The minimum age of the resource to filter. The provided duration will be rounded up to the nearest\n   * day/week/month/year value.\n   */\n  readonly age: cdk.Duration;\n\n  /**\n   * For age-based filters, the number of EC2 Image Builder images to keep on hand once the rule is applied. The value\n   * must be between 1 and 10.\n   *\n   * @default 0\n   */\n  readonly retainAtLeast?: number;\n}\n\n/**\n * The rules to apply for excluding EC2 Image Builder images from the lifecycle policy rule\n */\nexport interface LifecyclePolicyImageExclusionRules {\n  /**\n   * Excludes EC2 Image Builder images with any of the provided tags from the lifecycle policy rule\n   */\n  readonly tags: { [key: string]: string };\n}\n\n/**\n * The rules to apply for excluding AMIs from the lifecycle policy rule\n */\nexport interface LifecyclePolicyAmiExclusionRules {\n  /**\n   * Excludes public AMIs from the lifecycle policy rule if true\n   *\n   * @default false\n   */\n  readonly isPublic?: boolean;\n\n  /**\n   * Excludes AMIs which were launched from within the provided duration\n   *\n   * @default None\n   */\n  readonly lastLaunched?: cdk.Duration;\n\n  /**\n   * Excludes AMIs which reside in any of the provided regions\n   *\n   * @default None\n   */\n  readonly regions?: string[];\n\n  /**\n   * Excludes AMIs which are shared with any of the provided shared accounts\n   *\n   * @default None\n   */\n  readonly sharedAccounts?: string[];\n\n  /**\n   * Excludes AMIs which have any of the provided tags applied to it\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * The rules to apply for excluding resources from the lifecycle policy rule\n */\nexport interface LifecyclePolicyExclusionRules {\n  /**\n   * The rules to apply for excluding EC2 Image Builder images from the lifecycle policy rule\n   *\n   * @default - no exclusion rules are applied on the image\n   */\n  readonly imageExclusionRules?: LifecyclePolicyImageExclusionRules;\n\n  /**\n   * The rules to apply for excluding AMIs from the lifecycle policy rule\n   *\n   * @default - no exclusion rules are applied on the AMI\n   */\n  readonly amiExclusionRules?: LifecyclePolicyAmiExclusionRules;\n}\n\n/**\n * Configuration details for the lifecycle policy rules\n */\nexport interface LifecyclePolicyDetail {\n  /**\n   * The action to perform in the lifecycle policy rule\n   */\n  readonly action: LifecyclePolicyAction;\n\n  /**\n   * The resource filtering to apply in the lifecycle policy rule\n   */\n  readonly filter: LifecyclePolicyFilter;\n\n  /**\n   * The rules to apply for excluding resources from the lifecycle policy rule\n   *\n   * @default - no exclusion rules are applied on any resource\n   */\n  readonly exclusionRules?: LifecyclePolicyExclusionRules;\n}\n\n/**\n * Selection criteria for the resources that the lifecycle policy applies to\n */\nexport interface LifecyclePolicyResourceSelection {\n  /**\n   * The list of image recipes or container recipes to apply the lifecycle policy to\n   *\n   * @default - none if tag selections are provided. Otherwise, at least one recipe or tag selection must be provided\n   */\n  readonly recipes?: IRecipeBase[];\n\n  /**\n   * Selects EC2 Image Builder images containing any of the provided tags\n   *\n   * @default - none if recipe selections are provided. Otherwise, at least one recipe or tag selection must be provided\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Properties for creating a Lifecycle Policy resource\n */\nexport interface LifecyclePolicyProps {\n  /**\n   * The type of Image Builder resource that the lifecycle policy applies to.\n   */\n  readonly resourceType: LifecyclePolicyResourceType;\n\n  /**\n   * Configuration details for the lifecycle policy rules.\n   */\n  readonly details: LifecyclePolicyDetail[];\n\n  /**\n   * Selection criteria for the resources that the lifecycle policy applies to.\n   */\n  readonly resourceSelection: LifecyclePolicyResourceSelection;\n\n  /**\n   * The name of the lifecycle policy.\n   *\n   * @default - a name is generated\n   */\n  readonly lifecyclePolicyName?: string;\n\n  /**\n   * The description of the lifecycle policy.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The status of the lifecycle policy.\n   *\n   * @default LifecyclePolicyStatus.ENABLED\n   */\n  readonly status?: LifecyclePolicyStatus;\n\n  /**\n   * The execution role that grants Image Builder access to run lifecycle actions.\n   *\n   * By default, an execution role will be created with the minimal permissions needed to execute the lifecycle policy\n   * actions.\n   *\n   * @default - an execution role will be generated\n   */\n  readonly executionRole?: iam.IRole;\n\n  /**\n   * The tags to apply to the lifecycle policy\n   *\n   * @default - none\n   */\n  readonly tags?: { [key: string]: string };\n}\n\nabstract class LifecyclePolicyBase extends cdk.Resource implements ILifecyclePolicy {\n  abstract readonly lifecyclePolicyArn: string;\n  abstract readonly lifecyclePolicyName: string;\n\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.lifecyclePolicyArn],\n      scope: this,\n    });\n  }\n\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetLifecyclePolicy');\n  }\n}\n\n/**\n * Represents an EC2 Image Builder Lifecycle Policy.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-image-lifecycles.html\n */\n@propertyInjectable\nexport class LifecyclePolicy extends LifecyclePolicyBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.LifecyclePolicy';\n\n  /**\n   * Import an existing lifecycle policy given its ARN.\n   */\n  public static fromLifecyclePolicyArn(scope: Construct, id: string, lifecyclePolicyArn: string): ILifecyclePolicy {\n    const lifecyclePolicyName = cdk.Stack.of(scope).splitArn(\n      lifecyclePolicyArn,\n      cdk.ArnFormat.SLASH_RESOURCE_NAME,\n    ).resourceName!;\n\n    class Import extends LifecyclePolicyBase {\n      public readonly lifecyclePolicyArn = lifecyclePolicyArn;\n      public readonly lifecyclePolicyName = lifecyclePolicyName;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing lifecycle policy given its name. If the name is a token representing a dynamic CloudFormation\n   * expression, you must ensure all alphabetic characters in the expression are already lowercased\n   */\n  public static fromLifecyclePolicyName(scope: Construct, id: string, lifecyclePolicyName: string): ILifecyclePolicy {\n    return LifecyclePolicy.fromLifecyclePolicyArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'lifecycle-policy',\n        resourceName: lifecyclePolicyName,\n      }),\n    );\n  }\n\n  /**\n   * Return whether the given object is a LifecyclePolicy.\n   */\n  public static isLifecyclePolicy(x: any): x is LifecyclePolicy {\n    return x !== null && typeof x === 'object' && LIFECYCLE_POLICY_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the lifecycle policy\n   */\n  public readonly lifecyclePolicyArn: string;\n\n  /**\n   * The name of the lifecycle policy\n   */\n  public readonly lifecyclePolicyName: string;\n\n  /**\n   * The execution role used for lifecycle policy executions\n   */\n  public readonly executionRole: iam.IRole;\n\n  public constructor(scope: Construct, id: string, props: LifecyclePolicyProps) {\n    super(scope, id, {\n      physicalName:\n        props.lifecyclePolicyName ??\n        cdk.Lazy.string({\n          produce: () =>\n            cdk.Names.uniqueResourceName(this, {\n              maxLength: 128,\n              separator: '-',\n              allowedSpecialCharacters: '-',\n            }).toLowerCase(),\n        }),\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    Object.defineProperty(this, LIFECYCLE_POLICY_SYMBOL, { value: true });\n\n    this.validateLifecyclePolicyName();\n    this.validatePolicy(props);\n\n    this.executionRole =\n      props.executionRole ??\n      new iam.Role(this, 'ExecutionRole', {\n        assumedBy: new iam.ServicePrincipal('imagebuilder.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/EC2ImageBuilderLifecycleExecutionPolicy'),\n        ],\n      });\n\n    const lifecyclePolicy = new CfnLifecyclePolicy(this, 'Resource', {\n      name: this.physicalName,\n      description: props.description,\n      resourceType: props.resourceType,\n      executionRole: this.executionRole.roleArn,\n      policyDetails: this.buildPolicyDetails(props.resourceType, props.details),\n      resourceSelection: {\n        ...(props.resourceSelection.recipes !== undefined && {\n          recipes: this.buildRecipes(props.resourceType, props.resourceSelection.recipes),\n        }),\n        tagMap: props.resourceSelection.tags,\n      },\n      status: props.status,\n      tags: props.tags,\n    });\n\n    this.lifecyclePolicyName = this.getResourceNameAttribute(lifecyclePolicy.ref);\n    this.lifecyclePolicyArn = this.getResourceArnAttribute(lifecyclePolicy.attrArn, {\n      service: 'imagebuilder',\n      resource: 'lifecycle-policy',\n      resourceName: this.physicalName,\n    });\n  }\n\n  /**\n   * Generates the policy details property into the `PolicyDetail` type in the CloudFormation L1 definition.\n   *\n   * @param resourceType The resource type of the lifecycle policy\n   * @param details The lifecycle policy rules\n   * @private\n   */\n  private buildPolicyDetails(\n    resourceType: LifecyclePolicyResourceType,\n    details: LifecyclePolicyDetail[],\n  ): CfnLifecyclePolicy.PolicyDetailProperty[] {\n    return details.map((detail): CfnLifecyclePolicy.PolicyDetailProperty => {\n      const action = this.buildAction(resourceType, detail.action);\n      const exclusionRules =\n        detail.exclusionRules !== undefined ? this.buildExclusionRules(detail.exclusionRules) : undefined;\n\n      this.validatePolicyDetailAction(resourceType, detail.action, exclusionRules?.amis);\n      this.validatePolicyDetailFilter(detail.filter);\n\n      return {\n        action: action,\n        filter: {\n          retainAtLeast: detail.filter.ageFilter?.retainAtLeast,\n          type: detail.filter.ageFilter !== undefined ? 'AGE' : 'COUNT',\n          ...(detail.filter.ageFilter !== undefined\n            ? this.convertDurationToTimeUnitValue(detail.filter.ageFilter.age)\n            : { value: detail.filter.countFilter!.count }),\n        },\n        ...(exclusionRules !== undefined && { exclusionRules }),\n      };\n    });\n  }\n\n  /**\n   * Generates the recipes property in the resource selection into the `RecipeSelection` type in the CloudFormation L1\n   * definition.\n   *\n   * @param resourceType The resource type of the lifecycle policy\n   * @param recipes The recipes passed in the props\n   * @private\n   */\n  private buildRecipes(\n    resourceType: LifecyclePolicyResourceType,\n    recipes: IRecipeBase[],\n  ): CfnLifecyclePolicy.RecipeSelectionProperty[] | undefined {\n    return recipes?.map((recipe): CfnLifecyclePolicy.RecipeSelectionProperty => {\n      if (recipe._isImageRecipe()) {\n        if (resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE) {\n          throw new cdk.ValidationError(\n            `recipes in the resource selection must all be container recipes for policy type ${LifecyclePolicyResourceType.CONTAINER_IMAGE}`,\n            this,\n          );\n        }\n\n        return {\n          name: recipe.imageRecipeName,\n          semanticVersion: recipe.imageRecipeVersion,\n        };\n      }\n\n      if (recipe._isContainerRecipe()) {\n        if (resourceType === LifecyclePolicyResourceType.AMI_IMAGE) {\n          throw new cdk.ValidationError(\n            `recipes in the resource selection must all be image recipes for policy type ${LifecyclePolicyResourceType.AMI_IMAGE}`,\n            this,\n          );\n        }\n\n        return {\n          name: recipe.containerRecipeName,\n          semanticVersion: recipe.containerRecipeVersion,\n        };\n      }\n\n      throw new cdk.ValidationError(\n        'recipes in the resource selection must either be an IImageRecipe or IContainerRecipe',\n        this,\n      );\n    });\n  }\n\n  /**\n   * Generates the exclusion rules property into the `ExclusionRules` type in the CloudFormation L1 definition.\n   *\n   * @param exclusionRules The exclusion rules for resources applied in the lifecycle policy rule\n   * @private\n   */\n  private buildExclusionRules(\n    exclusionRules: LifecyclePolicyExclusionRules,\n  ): CfnLifecyclePolicy.ExclusionRulesProperty | undefined {\n    const amiExclusionRules: CfnLifecyclePolicy.AmiExclusionRulesProperty = {\n      ...(exclusionRules.amiExclusionRules?.isPublic && { isPublic: exclusionRules.amiExclusionRules.isPublic }),\n      ...(exclusionRules.amiExclusionRules?.lastLaunched !== undefined && {\n        lastLaunched: this.convertDurationToTimeUnitValue(exclusionRules.amiExclusionRules.lastLaunched, 365),\n      }),\n      ...(exclusionRules.amiExclusionRules?.regions?.length && { regions: exclusionRules.amiExclusionRules.regions }),\n      ...(exclusionRules.amiExclusionRules?.sharedAccounts?.length && {\n        sharedAccounts: exclusionRules.amiExclusionRules.sharedAccounts,\n      }),\n      ...(exclusionRules.amiExclusionRules?.tags && { tagMap: exclusionRules.amiExclusionRules.tags }),\n    };\n\n    const cfnExclusionRules: CfnLifecyclePolicy.ExclusionRulesProperty = {\n      ...(Object.keys(amiExclusionRules).length && { amis: amiExclusionRules }),\n      ...(exclusionRules.imageExclusionRules !== undefined && { tagMap: exclusionRules.imageExclusionRules.tags }),\n    };\n\n    return Object.keys(exclusionRules).length ? cfnExclusionRules : undefined;\n  }\n\n  /**\n   * Generates the action property into the `Action` type in the CloudFormation L1 definition.\n   *\n   * @param resourceType The resource type of the lifecycle policy\n   * @param action The action being taken in the lifecycle policy rule\n   * @private\n   */\n  private buildAction(\n    resourceType: LifecyclePolicyResourceType,\n    action: LifecyclePolicyAction,\n  ): CfnLifecyclePolicy.ActionProperty {\n    const isContainerPolicy =\n      !cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE;\n    const isAmiPolicy = !cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.AMI_IMAGE;\n\n    const amis = action.includeAmis ?? (isAmiPolicy ? true : undefined);\n    const snapshots = action.includeSnapshots ?? (isAmiPolicy ? true : undefined);\n    const containers = action.includeContainers ?? (isContainerPolicy ? true : undefined);\n    const includeResources: CfnLifecyclePolicy.IncludeResourcesProperty = {\n      ...(amis !== undefined && { amis }),\n      ...(snapshots !== undefined && { snapshots }),\n      ...(containers !== undefined && { containers }),\n    };\n\n    return {\n      type: action.type,\n      ...(Object.keys(includeResources).length && { includeResources }),\n    };\n  }\n\n  /**\n   * Validates the top-level properties of the policy\n   *\n   * @param props The props passed as input to the construct\n   * @private\n   */\n  private validatePolicy(props: LifecyclePolicyProps): void {\n    if (props.resourceSelection.recipes?.length && Object.keys(props.resourceSelection.tags || {}).length) {\n      throw new cdk.ValidationError('resource selection cannot contain both recipes and tags', this);\n    }\n\n    if (!props.resourceSelection.recipes?.length && !Object.keys(props.resourceSelection.tags || {}).length) {\n      throw new cdk.ValidationError('resource selection must contain either recipes or tags', this);\n    }\n\n    if (props.details.length === 0) {\n      throw new cdk.ValidationError('a lifecycle policy must have at least 1 rule', this);\n    }\n\n    if (props.details.length > 3) {\n      throw new cdk.ValidationError('a lifecycle policy can only have up to 3 rules', this);\n    }\n\n    const actions = props.details.map((detail) => detail.action.type);\n    if (new Set(actions).size != actions.length) {\n      throw new cdk.ValidationError('lifecycle policy rules may not have duplicate actions', this);\n    }\n  }\n\n  /**\n   * Validates a policy detail filter within a lifecycle policy rule\n   *\n   * @param resourceType The resource type of the lifecycle policy\n   * @param action The action being taken in the lifecycle policy rule\n   * @param amiExclusionRules The AMI exclusion rules in the lifecycle policy rule\n   * @private\n   */\n  private validatePolicyDetailAction(\n    resourceType: LifecyclePolicyResourceType,\n    action: LifecyclePolicyAction,\n    amiExclusionRules: CfnLifecyclePolicy.AmiExclusionRulesProperty | cdk.IResolvable | undefined,\n  ) {\n    if (!cdk.Token.isUnresolved(resourceType) && resourceType === LifecyclePolicyResourceType.CONTAINER_IMAGE) {\n      if (!cdk.Token.isUnresolved(action.type) && action.type !== LifecyclePolicyActionType.DELETE) {\n        throw new cdk.ValidationError('you may only specify DELETE rules for container policies', this);\n      }\n\n      if (action.includeAmis) {\n        throw new cdk.ValidationError('you cannot include AMIs in a container policy', this);\n      }\n\n      if (action.includeSnapshots) {\n        throw new cdk.ValidationError('you cannot include snapshots in a container policy', this);\n      }\n\n      if (amiExclusionRules !== undefined) {\n        throw new cdk.ValidationError('you cannot exclude AMIs in a container policy', this);\n      }\n    }\n\n    if (\n      !cdk.Token.isUnresolved(resourceType) &&\n      resourceType === LifecyclePolicyResourceType.AMI_IMAGE &&\n      action.includeContainers\n    ) {\n      throw new cdk.ValidationError('you cannot include containers in an AMI policy', this);\n    }\n  }\n\n  /**\n   * Validates a policy detail filter\n   *\n   * @param filter The lifecycle policy resource filter applied in the rule\n   * @private\n   */\n  private validatePolicyDetailFilter(filter: LifecyclePolicyFilter) {\n    if (filter.ageFilter !== undefined && filter.countFilter !== undefined) {\n      throw new cdk.ValidationError('either age count can be specified in a policy filter, but not both', this);\n    }\n\n    if (filter.ageFilter === undefined && filter.countFilter === undefined) {\n      throw new cdk.ValidationError('you must provide an age or count filter in the policy', this);\n    }\n\n    const retainAtLeast = filter.ageFilter?.retainAtLeast;\n    if (retainAtLeast !== undefined) {\n      if (retainAtLeast < 1) {\n        throw new cdk.ValidationError('the retainAtLeast filter value must be at least 1', this);\n      }\n      if (retainAtLeast > 10) {\n        throw new cdk.ValidationError('the retainAtLeast filter value must be at most 10', this);\n      }\n    }\n  }\n\n  /**\n   * Converts a `cdk.Duration` into the value and unit which is accepted as filter age and last launched age in the\n   * lifecycle policy. The value is rounded up to the nearest whole number.\n   *\n   * @param duration The duration to convert\n   * @param valueLimit The maximum value that can be specified\n   * @private\n   */\n  private convertDurationToTimeUnitValue(\n    duration: cdk.Duration,\n    valueLimit: number = 1000,\n  ): { value: number; unit: 'DAYS' | 'WEEKS' | 'MONTHS' | 'YEARS' } {\n    const DAYS_PER_WEEK = 7;\n    const DAYS_PER_MONTH = 30;\n    const DAYS_PER_YEAR = 365;\n\n    const valueInDays = Math.ceil(duration.toDays());\n    if (valueInDays < 1) {\n      throw new cdk.ValidationError('the provided duration must be at least 1 day', this);\n    }\n\n    if (valueInDays <= valueLimit) {\n      return { value: valueInDays, unit: 'DAYS' };\n    }\n\n    const valueInWeeks = Math.ceil(valueInDays / DAYS_PER_WEEK);\n    if (valueInWeeks <= valueLimit) {\n      return { value: valueInWeeks, unit: 'WEEKS' };\n    }\n\n    const valueInMonths = Math.ceil(valueInDays / DAYS_PER_MONTH);\n    if (valueInMonths <= valueLimit) {\n      return { value: valueInMonths, unit: 'MONTHS' };\n    }\n\n    const valueInYears = Math.ceil(valueInDays / DAYS_PER_YEAR);\n    if (valueInYears <= valueLimit) {\n      return { value: valueInYears, unit: 'YEARS' };\n    }\n\n    throw new cdk.ValidationError(`the provided duration must be less than ${valueLimit} years`, this);\n  }\n\n  private validateLifecyclePolicyName() {\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 lifecyclePolicyName cannot be longer than 128 characters', this);\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError('The lifecyclePolicyName cannot contain spaces', this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError('The lifecyclePolicyName cannot contain underscores', this);\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError('The lifecyclePolicyName must be lowercase', this);\n    }\n  }\n}\n"]}

package/lib/os-version.js

@@ -25,7 +25,7 @@ var Platform;
  * Represents an OS version for an EC2 Image Builder image
  */
 class OSVersion {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.OSVersion", version: "2.229.1-alpha.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.OSVersion", version: "2.231.0-alpha.0" };
     /**
      * OS version for all Linux images
      */

package/lib/private/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Represents the latest version of a resource. When using the resource, the latest version of it will be resolved
+ * when executing an image build.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html
+ */
+export declare const LATEST_VERSION = "x.x.x";

package/lib/private/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LATEST_VERSION = void 0;
+/**
+ * Represents the latest version of a resource. When using the resource, the latest version of it will be resolved
+ * when executing an image build.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html
+ */
+exports.LATEST_VERSION = 'x.x.x';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7OztHQUtHO0FBQ1UsUUFBQSxjQUFjLEdBQUcsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXByZXNlbnRzIHRoZSBsYXRlc3QgdmVyc2lvbiBvZiBhIHJlc291cmNlLiBXaGVuIHVzaW5nIHRoZSByZXNvdXJjZSwgdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIGl0IHdpbGwgYmUgcmVzb2x2ZWRcbiAqIHdoZW4gZXhlY3V0aW5nIGFuIGltYWdlIGJ1aWxkLlxuICpcbiAqIEBzZWUgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2ltYWdlYnVpbGRlci9sYXRlc3QvdXNlcmd1aWRlL2liaG93LXNlbWFudGljLXZlcnNpb25pbmcuaHRtbFxuICovXG5leHBvcnQgY29uc3QgTEFURVNUX1ZFUlNJT04gPSAneC54LngnO1xuIl19

package/lib/private/image-and-pipeline-props-helper.d.ts

@@ -0,0 +1,26 @@
+import { CfnImage, CfnImagePipeline } from 'aws-cdk-lib/aws-imagebuilder';
+import { Construct } from 'constructs';
+import { ImageProps } from '../image';
+import { ImagePipelineProps } from '../image-pipeline';
+/**
+ * Generates the image tests configuration property into the `ImageTestsConfiguration` type in the CloudFormation L1
+ * definition.
+ *
+ * @param props Props input for the construct
+ */
+export declare const buildImageTestsConfiguration: <PropsT extends ImagePipelineProps | ImageProps, OutputT extends CfnImagePipeline.ImageTestsConfigurationProperty | CfnImage.ImageTestsConfigurationProperty>(props: PropsT) => OutputT | undefined;
+/**
+ * Generates the image scanning configuration property into the `ImageScanningConfiguration` type in the CloudFormation
+ * L1 definition.
+ *
+ * @param scope The construct scope
+ * @param props Props input for the construct
+ */
+export declare const buildImageScanningConfiguration: <PropsT extends ImagePipelineProps | ImageProps, OutputT extends CfnImagePipeline.ImageScanningConfigurationProperty | CfnImage.ImageScanningConfigurationProperty>(scope: Construct, props: PropsT) => OutputT | undefined;
+/**
+ * Generates the workflows property into the `WorkflowConfiguration` type in the CloudFormation L1
+ * definition.
+ *
+ * @param props Props input for the construct
+ */
+export declare const buildWorkflows: <PropsT extends ImagePipelineProps | ImageProps, OutputT extends CfnImagePipeline.WorkflowConfigurationProperty[] | CfnImage.WorkflowConfigurationProperty[]>(props: PropsT) => OutputT | undefined;