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

package/lib/distribution-configuration.js

@@ -0,0 +1,413 @@
+"use strict";
+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;
+};
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributionConfiguration = exports.Repository = exports.RepositoryService = 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 DISTRIBUTION_CONFIGURATION_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.DistributionConfiguration');
+// Fast Launch requires at least 6 parallel launches.
+const MIN_PARALLEL_LAUNCHES = 6;
+/**
+ * A new or imported Distribution Configuration
+ */
+class DistributionConfigurationBase extends cdk.Resource {
+    /**
+     * Grant custom actions to the given grantee for the distribution configuration
+     *
+     * @param grantee The principal
+     * @param actions The list of actions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.distributionConfigurationArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant read permissions to the given grantee for the distribution configuration
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetDistributionConfiguration');
+    }
+}
+/**
+ * The service in which a container should be registered
+ */
+var RepositoryService;
+(function (RepositoryService) {
+    /**
+     * Indicates the container should be registered in ECR
+     */
+    RepositoryService["ECR"] = "ECR";
+})(RepositoryService || (exports.RepositoryService = RepositoryService = {}));
+/**
+ * A container repository used to distribute container images in EC2 Image Builder
+ */
+class Repository {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.Repository", version: "2.228.0-alpha.0" };
+    /**
+     * The ECR repository to use as the target container repository
+     *
+     * @param repository The ECR repository to use
+     */
+    static fromEcr(repository) {
+        class Import extends Repository {
+            repositoryName = repository.repositoryName;
+            service = RepositoryService.ECR;
+        }
+        return new Import();
+    }
+}
+exports.Repository = Repository;
+/**
+ * Represents an EC2 Image Builder Distribution Configuration.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-distribution-settings.html
+ */
+let DistributionConfiguration = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = DistributionConfigurationBase;
+    let _instanceExtraInitializers = [];
+    let _addAmiDistributions_decorators;
+    let _addContainerDistributions_decorators;
+    var DistributionConfiguration = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _addAmiDistributions_decorators = [(0, metadata_resource_1.MethodMetadata)()];
+            _addContainerDistributions_decorators = [(0, metadata_resource_1.MethodMetadata)()];
+            __esDecorate(this, null, _addAmiDistributions_decorators, { kind: "method", name: "addAmiDistributions", static: false, private: false, access: { has: obj => "addAmiDistributions" in obj, get: obj => obj.addAmiDistributions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _addContainerDistributions_decorators, { kind: "method", name: "addContainerDistributions", static: false, private: false, access: { has: obj => "addContainerDistributions" in obj, get: obj => obj.addContainerDistributions }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DistributionConfiguration = _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.DistributionConfiguration", version: "2.228.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.DistributionConfiguration';
+        /**
+         * Import an existing distribution configuration given its ARN.
+         */
+        static fromDistributionConfigurationArn(scope, id, distributionConfigurationArn) {
+            const distributionConfigurationName = cdk.Stack.of(scope).splitArn(distributionConfigurationArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+            class Import extends DistributionConfigurationBase {
+                distributionConfigurationArn = distributionConfigurationArn;
+                distributionConfigurationName = distributionConfigurationName;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Import an existing distribution configuration given its name. The provided name must be normalized by converting
+         * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.
+         */
+        static fromDistributionConfigurationName(scope, id, distributionConfigurationName) {
+            return this.fromDistributionConfigurationArn(scope, id, cdk.Stack.of(scope).formatArn({
+                service: 'imagebuilder',
+                resource: 'distribution-configuration',
+                resourceName: distributionConfigurationName,
+            }));
+        }
+        /**
+         * Return whether the given object is a DistributionConfiguration.
+         */
+        static isDistributionConfiguration(x) {
+            return x !== null && typeof x === 'object' && DISTRIBUTION_CONFIGURATION_SYMBOL in x;
+        }
+        /**
+         * The ARN of the distribution configuration
+         */
+        distributionConfigurationArn = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * The name of the distribution configuration
+         */
+        distributionConfigurationName;
+        amiDistributionsByRegion = {};
+        containerDistributionsByRegion = {};
+        constructor(scope, id, props = {}) {
+            super(scope, id, {
+                physicalName: props.distributionConfigurationName ??
+                    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_DistributionConfigurationProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, DistributionConfiguration);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, DISTRIBUTION_CONFIGURATION_SYMBOL, { value: true });
+            this.validateDistributionConfigurationName();
+            this.addAmiDistributions(...(props.amiDistributions ?? []));
+            this.addContainerDistributions(...(props.containerDistributions ?? []));
+            const distributionConfiguration = new aws_imagebuilder_1.CfnDistributionConfiguration(this, 'Resource', {
+                name: this.physicalName,
+                description: props.description,
+                distributions: cdk.Lazy.any({ produce: () => this.renderDistributions() }),
+                tags: props.tags,
+            });
+            this.distributionConfigurationName = this.getResourceNameAttribute(distributionConfiguration.attrName);
+            this.distributionConfigurationArn = this.getResourceArnAttribute(distributionConfiguration.attrArn, {
+                service: 'imagebuilder',
+                resource: 'distribution-configuration',
+                resourceName: this.physicalName,
+            });
+        }
+        /**
+         * Adds AMI distribution settings to the distribution configuration
+         *
+         * @param amiDistributions The list of AMI distribution settings to apply
+         */
+        addAmiDistributions(...amiDistributions) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_AmiDistribution(amiDistributions);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.addAmiDistributions);
+                }
+                throw error;
+            }
+            amiDistributions.forEach((amiDistribution) => {
+                const region = amiDistribution.region ?? cdk.Stack.of(this).region;
+                if (this.amiDistributionsByRegion[region]) {
+                    throw new cdk.ValidationError(`duplicate AMI distribution found for region "${region}"; only one AMI distribution per region is allowed`, this);
+                }
+                this.amiDistributionsByRegion[region] = amiDistribution;
+            });
+        }
+        /**
+         * Adds container distribution settings to the distribution configuration
+         *
+         * @param containerDistributions The list of container distribution settings to apply
+         */
+        addContainerDistributions(...containerDistributions) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ContainerDistribution(containerDistributions);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.addContainerDistributions);
+                }
+                throw error;
+            }
+            containerDistributions.forEach((containerDistribution) => {
+                const region = containerDistribution.region ?? cdk.Stack.of(this).region;
+                if (this.containerDistributionsByRegion[region]) {
+                    throw new cdk.ValidationError(`duplicate Container distribution found for region "${region}"; only one Container distribution per region is allowed`, this);
+                }
+                this.containerDistributionsByRegion[region] = containerDistribution;
+            });
+        }
+        validateDistributionConfigurationName() {
+            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 distributionConfigurationName cannot be longer than 128 characters', this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError('The distributionConfigurationName cannot contain spaces', this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError('The distributionConfigurationName cannot contain underscores', this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError('The distributionConfigurationName must be lowercase', this);
+            }
+        }
+        renderDistributions() {
+            if (!Object.keys(this.amiDistributionsByRegion).length &&
+                !Object.keys(this.containerDistributionsByRegion).length) {
+                throw new cdk.ValidationError('You must specify at least one AMI or container distribution', this);
+            }
+            const distributionByRegion = {};
+            for (const [region, distribution] of Object.entries(this.amiDistributionsByRegion)) {
+                distributionByRegion[region] = {
+                    region,
+                    amiDistributionConfiguration: this.buildAmiDistribution(distribution),
+                    fastLaunchConfigurations: this.buildFastLaunchConfigurations(distribution),
+                    launchTemplateConfigurations: this.buildLaunchTemplateConfigurations(distribution),
+                    ssmParameterConfigurations: this.buildSsmParameterConfigurations(distribution),
+                    licenseConfigurationArns: this.buildLicenseConfigurationArns(distribution),
+                };
+            }
+            for (const [region, containerDistribution] of Object.entries(this.containerDistributionsByRegion)) {
+                distributionByRegion[region] = {
+                    ...(distributionByRegion[region] ?? {}),
+                    region,
+                    containerDistributionConfiguration: this.buildContainerDistribution(containerDistribution),
+                };
+            }
+            const distributions = Object.values(distributionByRegion);
+            distributions.forEach((distribution) => {
+                const { region: _, ...distributionWithoutRegion } = distribution;
+                if (!Object.entries(distributionWithoutRegion).some(([__, value]) => value !== undefined)) {
+                    throw new cdk.ValidationError(`at least one distribution property must be set for region "${distribution.region}"`, this);
+                }
+            });
+            return distributions;
+        }
+        buildAmiDistribution(amiDistribution) {
+            const launchPermissions = this.buildAmiLaunchPermissions(amiDistribution);
+            const amiDistributionConfiguration = {
+                ...(Object.keys(amiDistribution.amiTags ?? {}).length && { AmiTags: amiDistribution.amiTags }),
+                ...(amiDistribution.amiDescription !== undefined && { Description: amiDistribution.amiDescription }),
+                ...(amiDistribution.amiKmsKey !== undefined && { KmsKeyId: amiDistribution.amiKmsKey.keyArn }),
+                ...(launchPermissions && { LaunchPermissionConfiguration: launchPermissions }),
+                ...(amiDistribution.amiName !== undefined && { Name: amiDistribution.amiName }),
+                ...(amiDistribution.amiTargetAccountIds !== undefined && {
+                    TargetAccountIds: amiDistribution.amiTargetAccountIds,
+                }),
+            };
+            return Object.keys(amiDistributionConfiguration).length ? amiDistributionConfiguration : undefined;
+        }
+        buildContainerDistribution(containerDistribution) {
+            return {
+                ContainerTags: containerDistribution.containerTags,
+                Description: containerDistribution.containerDescription,
+                TargetRepository: {
+                    RepositoryName: containerDistribution.containerRepository.repositoryName,
+                    Service: containerDistribution.containerRepository.service,
+                },
+            };
+        }
+        buildAmiLaunchPermissions(amiDistribution) {
+            if (amiDistribution.amiLaunchPermission?.isPublicUserGroup) {
+                cdk.Annotations.of(this).addWarning('AMI is configured for public access, making it available to any AWS account globally. ' +
+                    'Ensure no sensitive data, credentials, or proprietary configurations are included. ' +
+                    "Review your organization's security policies before deploying public AMIs.");
+            }
+            const launchPermissions = {
+                ...(amiDistribution.amiLaunchPermission?.organizationalUnitArns !== undefined && {
+                    OrganizationalUnitArns: amiDistribution.amiLaunchPermission?.organizationalUnitArns,
+                }),
+                ...(amiDistribution.amiLaunchPermission?.organizationArns !== undefined && {
+                    OrganizationArns: amiDistribution.amiLaunchPermission?.organizationArns,
+                }),
+                ...(amiDistribution.amiLaunchPermission?.isPublicUserGroup && {
+                    UserGroups: ['all'],
+                }),
+                ...(amiDistribution.amiLaunchPermission?.accountIds !== undefined && {
+                    UserIds: amiDistribution.amiLaunchPermission?.accountIds,
+                }),
+            };
+            return Object.keys(launchPermissions).length ? launchPermissions : undefined;
+        }
+        buildFastLaunchConfigurations(amiDistribution) {
+            const fastLaunchConfigurations = amiDistribution.fastLaunchConfigurations?.map((fastLaunchConfiguration) => {
+                if (fastLaunchConfiguration.maxParallelLaunches !== undefined &&
+                    !cdk.Token.isUnresolved(fastLaunchConfiguration.maxParallelLaunches) &&
+                    fastLaunchConfiguration.maxParallelLaunches < MIN_PARALLEL_LAUNCHES) {
+                    throw new cdk.ValidationError(`you must specify a maximum parallel launch count of at least ${MIN_PARALLEL_LAUNCHES}`, this);
+                }
+                const launchTemplate = fastLaunchConfiguration.launchTemplate;
+                const useFastLaunchLaunchTemplateId = launchTemplate?.launchTemplateId !== undefined;
+                const fastLaunchLaunchTemplate = {
+                    ...(useFastLaunchLaunchTemplateId && {
+                        launchTemplateId: launchTemplate?.launchTemplateId,
+                    }),
+                    ...(!useFastLaunchLaunchTemplateId && {
+                        launchTemplateName: launchTemplate?.launchTemplateName,
+                    }),
+                    ...(launchTemplate?.versionNumber !== undefined && {
+                        launchTemplateVersion: launchTemplate?.versionNumber,
+                    }),
+                };
+                return {
+                    enabled: fastLaunchConfiguration.enabled,
+                    maxParallelLaunches: fastLaunchConfiguration.maxParallelLaunches,
+                    ...(Object.keys(fastLaunchLaunchTemplate).length && { launchTemplate: fastLaunchLaunchTemplate }),
+                    ...(fastLaunchConfiguration.targetSnapshotCount !== undefined && {
+                        snapshotConfiguration: { targetResourceCount: fastLaunchConfiguration.targetSnapshotCount },
+                    }),
+                };
+            });
+            return fastLaunchConfigurations?.length ? fastLaunchConfigurations : undefined;
+        }
+        buildLaunchTemplateConfigurations(amiDistribution) {
+            const launchTemplateConfigurations = amiDistribution.launchTemplates?.map((launchTemplateConfiguration) => {
+                if (!launchTemplateConfiguration.launchTemplate.launchTemplateId) {
+                    throw new cdk.ValidationError('You must reference launch templates by ID in launch template configurations', this);
+                }
+                return {
+                    accountId: launchTemplateConfiguration.accountId,
+                    launchTemplateId: launchTemplateConfiguration.launchTemplate.launchTemplateId,
+                    setDefaultVersion: launchTemplateConfiguration.setDefaultVersion,
+                };
+            });
+            return launchTemplateConfigurations?.length ? launchTemplateConfigurations : undefined;
+        }
+        buildLicenseConfigurationArns(amiDistribution) {
+            return amiDistribution.licenseConfigurationArns?.length ? amiDistribution.licenseConfigurationArns : undefined;
+        }
+        buildSsmParameterConfigurations(amiDistribution) {
+            const ssmParameterConfigurations = amiDistribution.ssmParameters?.map((ssmParameterConfiguration) => ({
+                amiAccountId: ssmParameterConfiguration.amiAccount,
+                dataType: ssmParameterConfiguration.dataType,
+                parameterName: ssmParameterConfiguration.parameter.parameterName,
+            }));
+            return ssmParameterConfigurations?.length ? ssmParameterConfigurations : undefined;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return DistributionConfiguration = _classThis;
+})();
+exports.DistributionConfiguration = DistributionConfiguration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distribution-configuration.js","sourceRoot":"","sources":["distribution-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as ecr from 'aws-cdk-lib/aws-ecr';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CfnDistributionConfiguration } from 'aws-cdk-lib/aws-imagebuilder';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { addConstructMetadata, MethodMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport { Construct } from 'constructs';\n\nconst DISTRIBUTION_CONFIGURATION_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.DistributionConfiguration');\n\n// Fast Launch requires at least 6 parallel launches.\nconst MIN_PARALLEL_LAUNCHES = 6;\n\n/**\n * An EC2 Image Builder Distribution Configuration.\n */\nexport interface IDistributionConfiguration extends cdk.IResource {\n  /**\n   * The ARN of the distribution configuration\n   *\n   * @attribute\n   */\n  readonly distributionConfigurationArn: string;\n\n  /**\n   * The name of the distribution configuration\n   *\n   * @attribute\n   */\n  readonly distributionConfigurationName: string;\n\n  /**\n   * Grant custom actions to the given grantee for the distribution configuration\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 distribution configuration\n   *\n   * @param grantee The principal\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * The launch permissions for the AMI, defining which principals are allowed to access the AMI\n */\nexport interface AmiLaunchPermission {\n  /**\n   * The ARNs for the AWS Organizations organizational units to share the AMI with\n   *\n   * @default None\n   */\n  readonly organizationalUnitArns?: string[];\n\n  /**\n   * The ARNs for the AWS Organization that you want to share the AMI with\n   *\n   * @default None\n   */\n  readonly organizationArns?: string[];\n\n  /**\n   * Whether to make the AMI public. Block public access for AMIs must be disabled to make the AMI public.\n   *\n   * WARNING: Making an AMI public exposes it to any AWS account globally.\n   *  Ensure the AMI does not contain:\n   *  - Sensitive data or credentials\n   *  - Proprietary software or configurations\n   *  - Internal network information or security settings\n   *\n   * For more information on blocking public access for AMIs, see: [Understand block public access for AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html)\n   *\n   *\n   * @default false\n   */\n  readonly isPublicUserGroup?: boolean;\n\n  /**\n   * The AWS account IDs to share the AMI with\n   *\n   * @default None\n   */\n  readonly accountIds?: string[];\n}\n\n/**\n * The SSM parameters to create or update for the distributed AMIs\n */\nexport interface SSMParameterConfigurations {\n  /**\n   * The AWS account ID that will own the SSM parameter in the given region. This must be one of the target accounts\n   * that was included in the list of AMI distribution target accounts\n   *\n   * @default The current account is used\n   */\n  readonly amiAccount?: string;\n\n  /**\n   * The data type of the SSM parameter\n   *\n   * @default ssm.ParameterDataType.AWS_EC2_IMAGE\n   */\n  readonly dataType?: ssm.ParameterDataType;\n\n  /**\n   * The SSM parameter to create or update\n   */\n  readonly parameter: ssm.IStringParameter;\n}\n\n/**\n * The launch template to apply the distributed AMI to\n */\nexport interface LaunchTemplateConfiguration {\n  /**\n   * The launch template to apply the distributed AMI to. A new launch template version will be created for the\n   * provided launch template with the distributed AMI applied.\n   *\n   * *Note:* The launch template should expose a `launchTemplateId`. Templates\n   * imported by name only are not supported.\n   *\n   */\n  readonly launchTemplate: ec2.ILaunchTemplate;\n\n  /**\n   * The AWS account ID that owns the launch template\n   *\n   * @default The current account is used\n   */\n  readonly accountId?: string;\n\n  /**\n   * Whether to set the new launch template version that is created as the default launch template version. After\n   * creation of the launch template version containing the distributed AMI, it will be automatically set as the\n   * default version for the launch template.\n   *\n   * @default false\n   */\n  readonly setDefaultVersion?: boolean;\n}\n\n/**\n * The EC2 Fast Launch configuration to use for the Windows AMI\n */\nexport interface FastLaunchConfiguration {\n  /**\n   * Whether to enable fast launch for the AMI\n   *\n   * @default false\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The launch template that the fast-launch enabled Windows AMI uses when it launches Windows instances to create\n   * pre-provisioned snapshots\n   *\n   * @default None\n   */\n  readonly launchTemplate?: ec2.ILaunchTemplate;\n\n  /**\n   * The maximum number of parallel instances that are launched for creating resources\n   *\n   * @default A maximum of 6 instances are launched in parallel\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html\n   */\n  readonly maxParallelLaunches?: number;\n\n  /**\n   * The number of pre-provisioned snapshots to keep on hand for a fast-launch enabled Windows AMI\n   *\n   * @default 10 snapshots are kept pre-provisioned\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html\n   */\n  readonly targetSnapshotCount?: number;\n}\n\n/**\n * The regional distribution settings to use for an AMI build\n */\nexport interface AmiDistribution {\n  /**\n   * The target region to distribute AMIs to\n   *\n   * @default The current region is used\n   */\n  readonly region?: string;\n\n  /**\n   * The tags to apply to the distributed AMIs\n   *\n   * @default None\n   */\n  readonly amiTags?: { [key: string]: string };\n\n  /**\n   * The description of the AMI\n   *\n   * @default None\n   */\n  readonly amiDescription?: string;\n\n  /**\n   * The KMS key to encrypt the distributed AMI with\n   *\n   * @default None\n   */\n  readonly amiKmsKey?: kms.IKey;\n\n  /**\n   * The launch permissions for the AMI, defining which principals are allowed to access the AMI\n   *\n   * @default None\n   */\n  readonly amiLaunchPermission?: AmiLaunchPermission;\n\n  /**\n   * The name to use for the distributed AMIs\n   *\n   * @default A name is generated from the image recipe name\n   */\n  readonly amiName?: string;\n\n  /**\n   * The account IDs to copy the output AMI to\n   *\n   * @default None\n   */\n  readonly amiTargetAccountIds?: string[];\n\n  /**\n   * The SSM parameters to create or update for the distributed AMIs\n   *\n   * @default None\n   */\n  readonly ssmParameters?: SSMParameterConfigurations[];\n\n  /**\n   * The launch templates to apply the distributed AMI to\n   *\n   * @default None\n   */\n  readonly launchTemplates?: LaunchTemplateConfiguration[];\n\n  /**\n   * The fast launch configurations to use for enabling EC2 Fast Launch on the distributed Windows AMI\n   *\n   * @default None\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableFastLaunch.html\n   */\n  readonly fastLaunchConfigurations?: FastLaunchConfiguration[];\n\n  /**\n   * The License Manager license configuration ARNs to apply to the distributed AMIs\n   *\n   * @default None\n   */\n  readonly licenseConfigurationArns?: string[];\n}\n\n/**\n * The regional distribution settings to use for a container build\n */\nexport interface ContainerDistribution {\n  /**\n   * The target region to distribute containers to\n   *\n   * @default The current region is used\n   */\n  readonly region?: string;\n\n  /**\n   * The destination repository to distribute the output container to\n   *\n   * @default The target repository in the container recipe is used\n   */\n  readonly containerRepository: Repository;\n\n  /**\n   * The description of the container image\n   *\n   * @default None\n   */\n  readonly containerDescription?: string;\n\n  /**\n   * The additional tags to apply to the distributed container images\n   *\n   * @default None\n   */\n  readonly containerTags?: string[];\n}\n\n/**\n * Properties for creating a Distribution Configuration resource\n */\nexport interface DistributionConfigurationProps {\n  /**\n   * The list of target regions and associated AMI distribution settings where the built AMI will be distributed. AMI\n   * distributions may also be added with the `addAmiDistributions` method.\n   *\n   * @default None if container distributions are provided. Otherwise, at least one AMI or container distribution must\n   *          be provided\n   */\n  readonly amiDistributions?: AmiDistribution[];\n\n  /**\n   * The list of target regions and associated container distribution settings where the built container will be\n   * distributed. Container distributions may also be added with the `addContainerDistributions` method.\n   *\n   * @default None if AMI distributions are provided. Otherwise, at least one AMI or container distribution must be\n   *          provided\n   */\n  readonly containerDistributions?: ContainerDistribution[];\n\n  /**\n   * The name of the distribution configuration.\n   *\n   * @default A name is generated\n   */\n  readonly distributionConfigurationName?: string;\n\n  /**\n   * The description of the distribution configuration.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The tags to apply to the distribution configuration\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * A new or imported Distribution Configuration\n */\nabstract class DistributionConfigurationBase extends cdk.Resource implements IDistributionConfiguration {\n  /**\n   * The ARN of the distribution configuration\n   */\n  abstract readonly distributionConfigurationArn: string;\n\n  /**\n   * The name of the distribution configuration\n   */\n  abstract readonly distributionConfigurationName: string;\n\n  /**\n   * Grant custom actions to the given grantee for the distribution configuration\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.distributionConfigurationArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the distribution configuration\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetDistributionConfiguration');\n  }\n}\n\n/**\n * The service in which a container should be registered\n */\nexport enum RepositoryService {\n  /**\n   * Indicates the container should be registered in ECR\n   */\n  ECR = 'ECR',\n}\n\n/**\n * A container repository used to distribute container images in EC2 Image Builder\n */\nexport abstract class Repository {\n  /**\n   * The ECR repository to use as the target container repository\n   *\n   * @param repository The ECR repository to use\n   */\n  public static fromEcr(repository: ecr.IRepository): Repository {\n    class Import extends Repository {\n      public readonly repositoryName: string = repository.repositoryName;\n      public readonly service: RepositoryService = RepositoryService.ECR;\n    }\n\n    return new Import();\n  }\n\n  /**\n   * The name of the container repository where the output container image is stored\n   */\n  abstract readonly repositoryName: string;\n\n  /**\n   * The service in which the container repository is hosted\n   */\n  abstract readonly service: RepositoryService;\n}\n\n/**\n * Represents an EC2 Image Builder Distribution Configuration.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-distribution-settings.html\n */\n@propertyInjectable\nexport class DistributionConfiguration extends DistributionConfigurationBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.DistributionConfiguration';\n\n  /**\n   * Import an existing distribution configuration given its ARN.\n   */\n  public static fromDistributionConfigurationArn(\n    scope: Construct,\n    id: string,\n    distributionConfigurationArn: string,\n  ): IDistributionConfiguration {\n    const distributionConfigurationName = cdk.Stack.of(scope).splitArn(\n      distributionConfigurationArn,\n      cdk.ArnFormat.SLASH_RESOURCE_NAME,\n    ).resourceName!;\n\n    class Import extends DistributionConfigurationBase {\n      public readonly distributionConfigurationArn = distributionConfigurationArn;\n      public readonly distributionConfigurationName = distributionConfigurationName;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing distribution configuration given its name. The provided name must be normalized by converting\n   * all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.\n   */\n  public static fromDistributionConfigurationName(\n    scope: Construct,\n    id: string,\n    distributionConfigurationName: string,\n  ): IDistributionConfiguration {\n    return this.fromDistributionConfigurationArn(\n      scope,\n      id,\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'distribution-configuration',\n        resourceName: distributionConfigurationName,\n      }),\n    );\n  }\n\n  /**\n   * Return whether the given object is a DistributionConfiguration.\n   */\n  public static isDistributionConfiguration(x: any): x is DistributionConfiguration {\n    return x !== null && typeof x === 'object' && DISTRIBUTION_CONFIGURATION_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the distribution configuration\n   */\n  public readonly distributionConfigurationArn: string;\n\n  /**\n   * The name of the distribution configuration\n   */\n  public readonly distributionConfigurationName: string;\n\n  private readonly amiDistributionsByRegion: { [region: string]: AmiDistribution } = {};\n  private readonly containerDistributionsByRegion: {\n    [region: string]: ContainerDistribution;\n  } = {};\n\n  public constructor(scope: Construct, id: string, props: DistributionConfigurationProps = {}) {\n    super(scope, id, {\n      physicalName:\n        props.distributionConfigurationName ??\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, DISTRIBUTION_CONFIGURATION_SYMBOL, { value: true });\n\n    this.validateDistributionConfigurationName();\n\n    this.addAmiDistributions(...(props.amiDistributions ?? []));\n    this.addContainerDistributions(...(props.containerDistributions ?? []));\n\n    const distributionConfiguration = new CfnDistributionConfiguration(this, 'Resource', {\n      name: this.physicalName,\n      description: props.description,\n      distributions: cdk.Lazy.any({ produce: () => this.renderDistributions() }),\n      tags: props.tags,\n    });\n\n    this.distributionConfigurationName = this.getResourceNameAttribute(distributionConfiguration.attrName);\n    this.distributionConfigurationArn = this.getResourceArnAttribute(distributionConfiguration.attrArn, {\n      service: 'imagebuilder',\n      resource: 'distribution-configuration',\n      resourceName: this.physicalName,\n    });\n  }\n\n  /**\n   * Adds AMI distribution settings to the distribution configuration\n   *\n   * @param amiDistributions The list of AMI distribution settings to apply\n   */\n  @MethodMetadata()\n  public addAmiDistributions(...amiDistributions: AmiDistribution[]): void {\n    amiDistributions.forEach((amiDistribution) => {\n      const region = amiDistribution.region ?? cdk.Stack.of(this).region;\n      if (this.amiDistributionsByRegion[region]) {\n        throw new cdk.ValidationError(\n          `duplicate AMI distribution found for region \"${region}\"; only one AMI distribution per region is allowed`,\n          this,\n        );\n      }\n\n      this.amiDistributionsByRegion[region] = amiDistribution;\n    });\n  }\n\n  /**\n   * Adds container distribution settings to the distribution configuration\n   *\n   * @param containerDistributions The list of container distribution settings to apply\n   */\n  @MethodMetadata()\n  public addContainerDistributions(...containerDistributions: ContainerDistribution[]): void {\n    containerDistributions.forEach((containerDistribution) => {\n      const region = containerDistribution.region ?? cdk.Stack.of(this).region;\n      if (this.containerDistributionsByRegion[region]) {\n        throw new cdk.ValidationError(\n          `duplicate Container distribution found for region \"${region}\"; only one Container distribution per region is allowed`,\n          this,\n        );\n      }\n\n      this.containerDistributionsByRegion[region] = containerDistribution;\n    });\n  }\n\n  private validateDistributionConfigurationName() {\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 distributionConfigurationName cannot be longer than 128 characters', this);\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError('The distributionConfigurationName cannot contain spaces', this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError('The distributionConfigurationName cannot contain underscores', this);\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError('The distributionConfigurationName must be lowercase', this);\n    }\n  }\n\n  private renderDistributions(): CfnDistributionConfiguration.DistributionProperty[] {\n    if (\n      !Object.keys(this.amiDistributionsByRegion).length &&\n      !Object.keys(this.containerDistributionsByRegion).length\n    ) {\n      throw new cdk.ValidationError('You must specify at least one AMI or container distribution', this);\n    }\n\n    const distributionByRegion: { [region: string]: CfnDistributionConfiguration.DistributionProperty } = {};\n\n    for (const [region, distribution] of Object.entries(this.amiDistributionsByRegion)) {\n      distributionByRegion[region] = {\n        region,\n        amiDistributionConfiguration: this.buildAmiDistribution(distribution),\n        fastLaunchConfigurations: this.buildFastLaunchConfigurations(distribution),\n        launchTemplateConfigurations: this.buildLaunchTemplateConfigurations(distribution),\n        ssmParameterConfigurations: this.buildSsmParameterConfigurations(distribution),\n        licenseConfigurationArns: this.buildLicenseConfigurationArns(distribution),\n      };\n    }\n\n    for (const [region, containerDistribution] of Object.entries(this.containerDistributionsByRegion)) {\n      distributionByRegion[region] = {\n        ...(distributionByRegion[region] ?? {}),\n        region,\n        containerDistributionConfiguration: this.buildContainerDistribution(containerDistribution),\n      };\n    }\n\n    const distributions = Object.values(distributionByRegion);\n\n    distributions.forEach((distribution) => {\n      const { region: _, ...distributionWithoutRegion } = distribution;\n      if (!Object.entries(distributionWithoutRegion).some(([__, value]) => value !== undefined)) {\n        throw new cdk.ValidationError(\n          `at least one distribution property must be set for region \"${distribution.region}\"`,\n          this,\n        );\n      }\n    });\n\n    return distributions;\n  }\n\n  private buildAmiDistribution(amiDistribution: AmiDistribution): object | undefined {\n    const launchPermissions = this.buildAmiLaunchPermissions(amiDistribution);\n    const amiDistributionConfiguration = {\n      ...(Object.keys(amiDistribution.amiTags ?? {}).length && { AmiTags: amiDistribution.amiTags }),\n      ...(amiDistribution.amiDescription !== undefined && { Description: amiDistribution.amiDescription }),\n      ...(amiDistribution.amiKmsKey !== undefined && { KmsKeyId: amiDistribution.amiKmsKey.keyArn }),\n      ...(launchPermissions && { LaunchPermissionConfiguration: launchPermissions }),\n      ...(amiDistribution.amiName !== undefined && { Name: amiDistribution.amiName }),\n      ...(amiDistribution.amiTargetAccountIds !== undefined && {\n        TargetAccountIds: amiDistribution.amiTargetAccountIds,\n      }),\n    };\n\n    return Object.keys(amiDistributionConfiguration).length ? amiDistributionConfiguration : undefined;\n  }\n\n  private buildContainerDistribution(containerDistribution: ContainerDistribution): object | undefined {\n    return {\n      ContainerTags: containerDistribution.containerTags,\n      Description: containerDistribution.containerDescription,\n      TargetRepository: {\n        RepositoryName: containerDistribution.containerRepository.repositoryName,\n        Service: containerDistribution.containerRepository.service,\n      },\n    };\n  }\n\n  private buildAmiLaunchPermissions(amiDistribution: AmiDistribution): object | undefined {\n    if (amiDistribution.amiLaunchPermission?.isPublicUserGroup) {\n      cdk.Annotations.of(this).addWarning(\n        'AMI is configured for public access, making it available to any AWS account globally. ' +\n          'Ensure no sensitive data, credentials, or proprietary configurations are included. ' +\n          \"Review your organization's security policies before deploying public AMIs.\",\n      );\n    }\n\n    const launchPermissions = {\n      ...(amiDistribution.amiLaunchPermission?.organizationalUnitArns !== undefined && {\n        OrganizationalUnitArns: amiDistribution.amiLaunchPermission?.organizationalUnitArns,\n      }),\n      ...(amiDistribution.amiLaunchPermission?.organizationArns !== undefined && {\n        OrganizationArns: amiDistribution.amiLaunchPermission?.organizationArns,\n      }),\n      ...(amiDistribution.amiLaunchPermission?.isPublicUserGroup && {\n        UserGroups: ['all'],\n      }),\n      ...(amiDistribution.amiLaunchPermission?.accountIds !== undefined && {\n        UserIds: amiDistribution.amiLaunchPermission?.accountIds,\n      }),\n    };\n\n    return Object.keys(launchPermissions).length ? launchPermissions : undefined;\n  }\n\n  private buildFastLaunchConfigurations(\n    amiDistribution: AmiDistribution,\n  ): CfnDistributionConfiguration.FastLaunchConfigurationProperty[] | undefined {\n    const fastLaunchConfigurations = amiDistribution.fastLaunchConfigurations?.map(\n      (fastLaunchConfiguration): CfnDistributionConfiguration.FastLaunchConfigurationProperty => {\n        if (\n          fastLaunchConfiguration.maxParallelLaunches !== undefined &&\n          !cdk.Token.isUnresolved(fastLaunchConfiguration.maxParallelLaunches) &&\n          fastLaunchConfiguration.maxParallelLaunches < MIN_PARALLEL_LAUNCHES\n        ) {\n          throw new cdk.ValidationError(\n            `you must specify a maximum parallel launch count of at least ${MIN_PARALLEL_LAUNCHES}`,\n            this,\n          );\n        }\n\n        const launchTemplate = fastLaunchConfiguration.launchTemplate;\n        const useFastLaunchLaunchTemplateId = launchTemplate?.launchTemplateId !== undefined;\n        const fastLaunchLaunchTemplate: CfnDistributionConfiguration.FastLaunchLaunchTemplateSpecificationProperty = {\n          ...(useFastLaunchLaunchTemplateId && {\n            launchTemplateId: launchTemplate?.launchTemplateId,\n          }),\n          ...(!useFastLaunchLaunchTemplateId && {\n            launchTemplateName: launchTemplate?.launchTemplateName,\n          }),\n          ...(launchTemplate?.versionNumber !== undefined && {\n            launchTemplateVersion: launchTemplate?.versionNumber,\n          }),\n        };\n\n        return {\n          enabled: fastLaunchConfiguration.enabled,\n          maxParallelLaunches: fastLaunchConfiguration.maxParallelLaunches,\n          ...(Object.keys(fastLaunchLaunchTemplate).length && { launchTemplate: fastLaunchLaunchTemplate }),\n          ...(fastLaunchConfiguration.targetSnapshotCount !== undefined && {\n            snapshotConfiguration: { targetResourceCount: fastLaunchConfiguration.targetSnapshotCount },\n          }),\n        };\n      },\n    );\n\n    return fastLaunchConfigurations?.length ? fastLaunchConfigurations : undefined;\n  }\n\n  private buildLaunchTemplateConfigurations(\n    amiDistribution: AmiDistribution,\n  ): CfnDistributionConfiguration.LaunchTemplateConfigurationProperty[] | undefined {\n    const launchTemplateConfigurations = amiDistribution.launchTemplates?.map(\n      (launchTemplateConfiguration): CfnDistributionConfiguration.LaunchTemplateConfigurationProperty => {\n        if (!launchTemplateConfiguration.launchTemplate.launchTemplateId) {\n          throw new cdk.ValidationError(\n            'You must reference launch templates by ID in launch template configurations',\n            this,\n          );\n        }\n\n        return {\n          accountId: launchTemplateConfiguration.accountId,\n          launchTemplateId: launchTemplateConfiguration.launchTemplate.launchTemplateId,\n          setDefaultVersion: launchTemplateConfiguration.setDefaultVersion,\n        };\n      },\n    );\n\n    return launchTemplateConfigurations?.length ? launchTemplateConfigurations : undefined;\n  }\n\n  private buildLicenseConfigurationArns(amiDistribution: AmiDistribution): string[] | undefined {\n    return amiDistribution.licenseConfigurationArns?.length ? amiDistribution.licenseConfigurationArns : undefined;\n  }\n\n  private buildSsmParameterConfigurations(\n    amiDistribution: AmiDistribution,\n  ): CfnDistributionConfiguration.SsmParameterConfigurationProperty[] | undefined {\n    const ssmParameterConfigurations = amiDistribution.ssmParameters?.map(\n      (ssmParameterConfiguration): CfnDistributionConfiguration.SsmParameterConfigurationProperty => ({\n        amiAccountId: ssmParameterConfiguration.amiAccount,\n        dataType: ssmParameterConfiguration.dataType,\n        parameterName: ssmParameterConfiguration.parameter.parameterName,\n      }),\n    );\n\n    return ssmParameterConfigurations?.length ? ssmParameterConfigurations : undefined;\n  }\n}\n"]}

package/lib/index.d.ts

@@ -1 +1,4 @@
+export * from './component';
+export * from './distribution-configuration';
 export * from './infrastructure-configuration';
+export * from './os-version';

package/lib/index.js

@@ -15,5 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./component"), exports);
+__exportStar(require("./distribution-configuration"), exports);
 __exportStar(require("./infrastructure-configuration"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsOENBQThDOzs7Ozs7Ozs7Ozs7Ozs7O0FBRTlDLGlFQUErQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEFXUzo6SW1hZ2VCdWlsZGVyIENsb3VkRm9ybWF0aW9uIFJlc291cmNlczpcblxuZXhwb3J0ICogZnJvbSAnLi9pbmZyYXN0cnVjdHVyZS1jb25maWd1cmF0aW9uJztcbiJdfQ==
+__exportStar(require("./os-version"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsOENBQThDOzs7Ozs7Ozs7Ozs7Ozs7O0FBRTlDLDhDQUE0QjtBQUM1QiwrREFBNkM7QUFDN0MsaUVBQStDO0FBRS9DLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEFXUzo6SW1hZ2VCdWlsZGVyIENsb3VkRm9ybWF0aW9uIFJlc291cmNlczpcblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXN0cmlidXRpb24tY29uZmlndXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2luZnJhc3RydWN0dXJlLWNvbmZpZ3VyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL29zLXZlcnNpb24nO1xuIl19

package/lib/infrastructure-configuration.js

@@ -125,7 +125,7 @@ let InfrastructureConfiguration = (() => {
             InfrastructureConfiguration = _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.InfrastructureConfiguration", version: "2.226.0-alpha.0" };
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.InfrastructureConfiguration", version: "2.228.0-alpha.0" };
         /** Uniquely identifies this class. */
         static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.InfrastructureConfiguration';
         /**