npm - @aws-cdk/aws-elasticache-alpha - Versions diffs - 2.219.0-alpha.0 → 2.221.0-alpha.0 - Mend

@aws-cdk/aws-elasticache-alpha 2.219.0-alpha.0 → 2.221.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/.jsii +19 -19
package/.jsii.tabl.json.gz +0 -0
package/lib/iam-user.js +159 -82
package/lib/no-password-user.js +130 -55
package/lib/password-user.js +131 -56
package/lib/serverless-cache-base.js +2 -4
package/lib/serverless-cache.js +451 -358
package/lib/user-base.js +11 -6
package/lib/user-group.js +241 -182
package/package.json +9 -8

package/lib/serverless-cache.js CHANGED Viewed

@@ -1,12 +1,38 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+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;
 };
-var _a;
-var ServerlessCache_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerlessCache = void 0;
 const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
@@ -50,380 +76,447 @@ const REQUEST_RATE_MAX_ECPU = 15000000;
  *
  * @resource AWS::ElastiCache::ServerlessCache
  */
-let ServerlessCache = ServerlessCache_1 = class ServerlessCache extends serverless_cache_base_1.ServerlessCacheBase {
-    /**
-     * Return whether the given object is a `ServerlessCache`
-     */
-    static isServerlessCache(x) {
-        return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;
-    }
-    /**
-     * Import an existing serverless cache by name
-     *
-     * @param scope The parent creating construct (usually `this`)
-     * @param id The construct's name
-     * @param serverlessCacheName The name of the existing serverless cache
-     */
-    static fromServerlessCacheName(scope, id, serverlessCacheName) {
-        return ServerlessCache_1.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });
-    }
-    /**
-     * Import an existing serverless cache by ARN
-     *
-     * @param scope The parent creating construct (usually `this`)
-     * @param id The construct's name
-     * @param serverlessCacheArn The ARN of the existing serverless cache
-     */
-    static fromServerlessCacheArn(scope, id, serverlessCacheArn) {
-        return ServerlessCache_1.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });
-    }
-    /**
-     * Import an existing serverless cache using attributes
-     *
-     * @param scope The parent creating construct (usually `this`)
-     * @param id The construct's name
-     * @param attrs A `ServerlessCacheAttributes` object
-     */
-    static fromServerlessCacheAttributes(scope, id, attrs) {
-        try {
-            jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheAttributes(attrs);
-        }
-        catch (error) {
-            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
-                Error.captureStackTrace(error, this.fromServerlessCacheAttributes);
-            }
-            throw error;
+let ServerlessCache = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = serverless_cache_base_1.ServerlessCacheBase;
+    var ServerlessCache = 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);
+            ServerlessCache = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        let name;
-        let arn;
-        const stack = core_1.Stack.of(scope);
-        if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {
-            throw new core_1.ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-elasticache-alpha.ServerlessCache", version: "2.221.0-alpha.0" };
+        /**
+         * Uniquely identifies this class.
+         */
+        static PROPERTY_INJECTION_ID = 'aws-cdk-lib.aws-elasticache.ServerlessCache';
+        /**
+         * Return whether the given object is a `ServerlessCache`
+         */
+        static isServerlessCache(x) {
+            return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;
         }
-        if (attrs.serverlessCacheArn) {
-            arn = attrs.serverlessCacheArn;
-            const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, core_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
-            if (!extractedServerlessCacheName) {
-                throw new core_1.ValidationError('Unable to extract serverless cache name from ARN.', scope);
-            }
-            name = extractedServerlessCacheName;
-        }
-        else if (attrs.serverlessCacheName) {
-            name = attrs.serverlessCacheName;
-            arn = stack.formatArn({
-                service: 'elasticache',
-                resource: 'serverlesscache',
-                resourceName: attrs.serverlessCacheName,
-            });
+        /**
+         * Import an existing serverless cache by name
+         *
+         * @param scope The parent creating construct (usually `this`)
+         * @param id The construct's name
+         * @param serverlessCacheName The name of the existing serverless cache
+         */
+        static fromServerlessCacheName(scope, id, serverlessCacheName) {
+            return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });
         }
-        else {
-            throw new core_1.ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);
+        /**
+         * Import an existing serverless cache by ARN
+         *
+         * @param scope The parent creating construct (usually `this`)
+         * @param id The construct's name
+         * @param serverlessCacheArn The ARN of the existing serverless cache
+         */
+        static fromServerlessCacheArn(scope, id, serverlessCacheArn) {
+            return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });
         }
-        class Import extends serverless_cache_base_1.ServerlessCacheBase {
-            constructor(serverlessCacheArn, serverlessCacheName) {
-                super(scope, id);
-                this.engine = attrs.engine;
-                this.backupArnsToRestore = attrs.backupArnsToRestore;
-                this.kmsKey = attrs.kmsKey;
-                this.vpc = attrs.vpc;
-                this.subnets = attrs.subnets;
-                this.securityGroups = attrs.securityGroups;
-                this.userGroup = attrs.userGroup;
-                this.serverlessCacheArn = serverlessCacheArn;
-                this.serverlessCacheName = serverlessCacheName;
-                if (this.engine) {
-                    let defaultPort;
-                    switch (this.engine) {
-                        case serverless_cache_base_1.CacheEngine.VALKEY_LATEST:
-                        case serverless_cache_base_1.CacheEngine.VALKEY_7:
-                        case serverless_cache_base_1.CacheEngine.VALKEY_8:
-                        case serverless_cache_base_1.CacheEngine.REDIS_LATEST:
-                            // Document showing the default port
-                            // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
-                            defaultPort = ec2.Port.tcp(6379);
-                            break;
-                        case serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST:
-                            // Document showing the default port
-                            // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
-                            defaultPort = ec2.Port.tcp(11211);
-                            break;
-                        default:
-                            throw new core_1.ValidationError(`Unsupported cache engine: ${this.engine}`, scope);
-                    }
-                    this.connections = new ec2.Connections({
-                        securityGroups: this.securityGroups,
-                        defaultPort: defaultPort,
-                    });
+        /**
+         * Import an existing serverless cache using attributes
+         *
+         * @param scope The parent creating construct (usually `this`)
+         * @param id The construct's name
+         * @param attrs A `ServerlessCacheAttributes` object
+         */
+        static fromServerlessCacheAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromServerlessCacheAttributes);
                 }
-                else {
-                    this.connections = new ec2.Connections({
-                        securityGroups: this.securityGroups,
-                    });
+                throw error;
+            }
+            let name;
+            let arn;
+            const stack = core_1.Stack.of(scope);
+            if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {
+                throw new core_1.ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);
+            }
+            if (attrs.serverlessCacheArn) {
+                arn = attrs.serverlessCacheArn;
+                const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, core_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+                if (!extractedServerlessCacheName) {
+                    throw new core_1.ValidationError('Unable to extract serverless cache name from ARN.', scope);
                 }
+                name = extractedServerlessCacheName;
             }
-        }
-        return new Import(arn, name);
-    }
-    constructor(scope, id, props) {
-        super(scope, id, {});
-        try {
-            jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheProps(props);
-        }
-        catch (error) {
-            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
-                Error.captureStackTrace(error, ServerlessCache);
+            else if (attrs.serverlessCacheName) {
+                name = attrs.serverlessCacheName;
+                arn = stack.formatArn({
+                    service: 'elasticache',
+                    resource: 'serverlesscache',
+                    resourceName: attrs.serverlessCacheName,
+                });
             }
-            throw error;
-        }
-        // Enhanced CDK Analytics Telemetry
-        (0, metadata_resource_1.addConstructMetadata)(this, props);
-        this.engine = props.engine ?? serverless_cache_base_1.CacheEngine.VALKEY_LATEST;
-        this.serverlessCacheName = props.serverlessCacheName ?? core_1.Lazy.string({ produce: () => core_1.Names.uniqueId(this) });
-        this.kmsKey = props.kmsKey;
-        this.vpc = props.vpc;
-        this.userGroup = props.userGroup;
-        this.validateDescription(props.description);
-        this.validateDataStorageLimits(props.cacheUsageLimits);
-        this.validateRequestRateLimits(props.cacheUsageLimits);
-        this.validateBackupSettings(props.backup);
-        this.validateUserGroupCompatibility(this.engine, this.userGroup);
-        const subnetConfig = this.configureSubnets(props);
-        const subnetIds = subnetConfig.subnetIds;
-        this.subnets = subnetConfig.subnets;
-        const securityGroupConfig = this.configureSecurityGroups(props);
-        const securityGroupIds = securityGroupConfig.securityGroupIds;
-        this.securityGroups = securityGroupConfig.securityGroups;
-        const [engine, version] = this.engine.split('_');
-        const resource = new aws_elasticache_1.CfnServerlessCache(this, 'Resource', {
-            engine: engine,
-            majorEngineVersion: version,
-            serverlessCacheName: this.serverlessCacheName,
-            description: props.description,
-            cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),
-            dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,
-            snapshotRetentionLimit: props.backup?.backupRetentionLimit,
-            finalSnapshotName: props.backup?.backupNameBeforeDeletion,
-            snapshotArnsToRestore: props.backup?.backupArnsToRestore,
-            kmsKeyId: props.kmsKey?.keyId,
-            subnetIds: subnetIds,
-            securityGroupIds: securityGroupIds,
-            userGroupId: props.userGroup?.userGroupName,
-        });
-        if (props.userGroup) {
-            const userGroupResource = props.userGroup.node.findChild('Resource');
-            resource.addDependency(userGroupResource);
-        }
-        this.backupArnsToRestore = resource.snapshotArnsToRestore;
-        this.serverlessCacheArn = resource.attrArn;
-        this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;
-        this.serverlessCacheEndpointPort = resource.attrEndpointPort;
-        this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;
-        this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;
-        this.serverlessCacheStatus = resource.attrStatus;
-        this.connections = new ec2.Connections({
-            securityGroups: this.securityGroups,
-            defaultPort: ec2.Port.tcp(core_1.Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),
-        });
-        Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });
-    }
-    /**
-     * Validate description meets AWS requirements
-     *
-     * @param description The description to validate
-     */
-    validateDescription(description) {
-        if (!description || core_1.Token.isUnresolved(description))
-            return;
-        if (description.length > 255) {
-            throw new core_1.ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);
-        }
-        if (description.includes('<') || description.includes('>')) {
-            throw new core_1.ValidationError('Description must not contain < or > characters', this);
-        }
-    }
-    /**
-     * Validate data storage size limits
-     *
-     * @param limits The usage limits containing data storage settings
-     */
-    validateDataStorageLimits(limits) {
-        if (!limits)
-            return;
-        if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&
-            (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
-            throw new core_1.ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);
-        }
-        if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&
-            (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
-            throw new core_1.ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);
-        }
-        if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&
-            !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&
-            limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {
-            throw new core_1.ValidationError('Data storage minimum cannot be greater than maximum', this);
-        }
-    }
-    /**
-     * Validate request rate limits
-     *
-     * @param limits The usage limits containing request rate settings
-     */
-    validateRequestRateLimits(limits) {
-        if (!limits)
-            return;
-        if (limits.requestRateLimitMinimum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMinimum) &&
-            (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {
-            throw new core_1.ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);
-        }
-        if (limits.requestRateLimitMaximum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
-            (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {
-            throw new core_1.ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);
-        }
-        if (!core_1.Token.isUnresolved(limits.requestRateLimitMinimum) && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
-            limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&
-            limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {
-            throw new core_1.ValidationError('Request rate minimum cannot be greater than maximum', this);
-        }
-    }
-    /**
-     * Validate backup settings meet AWS requirements
-     *
-     * @param backup The backup settings to validate
-     */
-    validateBackupSettings(backup) {
-        if (!core_1.Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {
-            const limit = backup.backupRetentionLimit;
-            if (limit < 1 || limit > 35) {
-                throw new core_1.ValidationError('Backup retention limit must be between 1 and 35 days', this);
+            else {
+                throw new core_1.ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);
             }
-        }
-        if (!core_1.Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {
-            const name = backup.backupNameBeforeDeletion;
-            if (!/^[a-zA-Z]/.test(name)) {
-                throw new core_1.ValidationError('Final backup name must begin with a letter', this);
+            class Import extends serverless_cache_base_1.ServerlessCacheBase {
+                engine = attrs.engine;
+                serverlessCacheName;
+                serverlessCacheArn;
+                backupArnsToRestore = attrs.backupArnsToRestore;
+                kmsKey = attrs.kmsKey;
+                vpc = attrs.vpc;
+                subnets = attrs.subnets;
+                securityGroups = attrs.securityGroups;
+                userGroup = attrs.userGroup;
+                connections;
+                constructor(serverlessCacheArn, serverlessCacheName) {
+                    super(scope, id);
+                    this.serverlessCacheArn = serverlessCacheArn;
+                    this.serverlessCacheName = serverlessCacheName;
+                    if (this.engine) {
+                        let defaultPort;
+                        switch (this.engine) {
+                            case serverless_cache_base_1.CacheEngine.VALKEY_LATEST:
+                            case serverless_cache_base_1.CacheEngine.VALKEY_7:
+                            case serverless_cache_base_1.CacheEngine.VALKEY_8:
+                            case serverless_cache_base_1.CacheEngine.REDIS_LATEST:
+                            case serverless_cache_base_1.CacheEngine.REDIS_7:
+                                // Document showing the default port
+                                // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
+                                defaultPort = ec2.Port.tcp(6379);
+                                break;
+                            case serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST:
+                                // Document showing the default port
+                                // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN
+                                defaultPort = ec2.Port.tcp(11211);
+                                break;
+                            default:
+                                throw new core_1.ValidationError(`Unsupported cache engine: ${this.engine}`, scope);
+                        }
+                        this.connections = new ec2.Connections({
+                            securityGroups: this.securityGroups,
+                            defaultPort: defaultPort,
+                        });
+                    }
+                    else {
+                        this.connections = new ec2.Connections({
+                            securityGroups: this.securityGroups,
+                        });
+                    }
+                }
             }
-            if (!/^[a-zA-Z0-9-]+$/.test(name)) {
-                throw new core_1.ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);
+            return new Import(arn, name);
+        }
+        engine;
+        serverlessCacheName;
+        backupArnsToRestore;
+        kmsKey;
+        vpc;
+        subnets;
+        securityGroups;
+        userGroup;
+        /**
+         * The ARN of the serverless cache
+         *
+         * @attribute
+         */
+        serverlessCacheArn;
+        /**
+         * The endpoint address of the serverless cache
+         *
+         * @attribute
+         */
+        serverlessCacheEndpointAddress;
+        /**
+         * The endpoint port of the serverless cache
+         *
+         * @attribute
+         */
+        serverlessCacheEndpointPort;
+        /**
+         * The reader endpoint address of the serverless cache
+         *
+         * @attribute
+         */
+        serverlessCacheReaderEndpointAddress;
+        /**
+         * The reader endpoint port of the serverless cache
+         *
+         * @attribute
+         */
+        serverlessCacheReaderEndpointPort;
+        /**
+         * The current status of the serverless cache
+         * Can be 'CREATING', 'AVAILABLE', 'DELETING', 'CREATE-FAILED', 'MODIFYING'
+         *
+         * @attribute
+         */
+        serverlessCacheStatus;
+        /**
+         * Access to network connections
+         */
+        connections;
+        constructor(scope, id, props) {
+            super(scope, id, {});
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_elasticache_alpha_ServerlessCacheProps(props);
             }
-            if (name.endsWith('-')) {
-                throw new core_1.ValidationError('Final backup name must not end with a hyphen', this);
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, ServerlessCache);
+                }
+                throw error;
             }
-            if (name.includes('--')) {
-                throw new core_1.ValidationError('Final backup name must not contain two consecutive hyphens', this);
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            this.engine = props.engine ?? serverless_cache_base_1.CacheEngine.VALKEY_LATEST;
+            this.serverlessCacheName = props.serverlessCacheName ?? core_1.Lazy.string({ produce: () => core_1.Names.uniqueId(this) });
+            this.kmsKey = props.kmsKey;
+            this.vpc = props.vpc;
+            this.userGroup = props.userGroup;
+            this.validateDescription(props.description);
+            this.validateDataStorageLimits(props.cacheUsageLimits);
+            this.validateRequestRateLimits(props.cacheUsageLimits);
+            this.validateBackupSettings(props.backup);
+            this.validateUserGroupCompatibility(this.engine, this.userGroup);
+            const subnetConfig = this.configureSubnets(props);
+            const subnetIds = subnetConfig.subnetIds;
+            this.subnets = subnetConfig.subnets;
+            const securityGroupConfig = this.configureSecurityGroups(props);
+            const securityGroupIds = securityGroupConfig.securityGroupIds;
+            this.securityGroups = securityGroupConfig.securityGroups;
+            const [engine, version] = this.engine.split('_');
+            const resource = new aws_elasticache_1.CfnServerlessCache(this, 'Resource', {
+                engine: engine,
+                majorEngineVersion: version,
+                serverlessCacheName: this.serverlessCacheName,
+                description: props.description,
+                cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),
+                dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,
+                snapshotRetentionLimit: props.backup?.backupRetentionLimit,
+                finalSnapshotName: props.backup?.backupNameBeforeDeletion,
+                snapshotArnsToRestore: props.backup?.backupArnsToRestore,
+                kmsKeyId: props.kmsKey?.keyId,
+                subnetIds: subnetIds,
+                securityGroupIds: securityGroupIds,
+                userGroupId: props.userGroup?.userGroupName,
+            });
+            if (props.userGroup) {
+                const userGroupResource = props.userGroup.node.findChild('Resource');
+                resource.addDependency(userGroupResource);
             }
+            this.backupArnsToRestore = resource.snapshotArnsToRestore;
+            this.serverlessCacheArn = resource.attrArn;
+            this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;
+            this.serverlessCacheEndpointPort = resource.attrEndpointPort;
+            this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;
+            this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;
+            this.serverlessCacheStatus = resource.attrStatus;
+            this.connections = new ec2.Connections({
+                securityGroups: this.securityGroups,
+                defaultPort: ec2.Port.tcp(core_1.Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),
+            });
+            Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });
         }
-    }
-    /**
-     * Validate user group compatibility with cache engine
-     *
-     * @param engine The cache engine
-     * @param userGroup The user group to validate
-     */
-    validateUserGroupCompatibility(engine, userGroup) {
-        if (!userGroup)
-            return;
-        if (engine === serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST) {
-            throw new core_1.ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);
+        /**
+         * Validate description meets AWS requirements
+         *
+         * @param description The description to validate
+         */
+        validateDescription(description) {
+            if (!description || core_1.Token.isUnresolved(description))
+                return;
+            if (description.length > 255) {
+                throw new core_1.ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);
+            }
+            if (description.includes('<') || description.includes('>')) {
+                throw new core_1.ValidationError('Description must not contain < or > characters', this);
+            }
         }
-        if (engine === serverless_cache_base_1.CacheEngine.REDIS_LATEST && userGroup.engine !== common_1.UserEngine.REDIS) {
-            throw new core_1.ValidationError('Redis cache can only use Redis user groups.', this);
+        /**
+         * Validate data storage size limits
+         *
+         * @param limits The usage limits containing data storage settings
+         */
+        validateDataStorageLimits(limits) {
+            if (!limits)
+                return;
+            if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&
+                (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
+                throw new core_1.ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);
+            }
+            if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&
+                (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {
+                throw new core_1.ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);
+            }
+            if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&
+                !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&
+                limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {
+                throw new core_1.ValidationError('Data storage minimum cannot be greater than maximum', this);
+            }
         }
-    }
-    /**
-     * Render cache usage limits for CloudFormation
-     *
-     * @param limits The usage limits to render
-     * @returns CloudFormation-compatible usage limits object or undefined
-     */
-    renderCacheUsageLimits(limits) {
-        if (!limits)
-            return undefined;
-        const cacheUsageLimits = {};
-        if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {
-            cacheUsageLimits.dataStorage = {
-                unit: DataStorageUnit.GIGABYTES,
-                ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),
-                ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),
-            };
+        /**
+         * Validate request rate limits
+         *
+         * @param limits The usage limits containing request rate settings
+         */
+        validateRequestRateLimits(limits) {
+            if (!limits)
+                return;
+            if (limits.requestRateLimitMinimum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMinimum) &&
+                (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {
+                throw new core_1.ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);
+            }
+            if (limits.requestRateLimitMaximum !== undefined && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
+                (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {
+                throw new core_1.ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);
+            }
+            if (!core_1.Token.isUnresolved(limits.requestRateLimitMinimum) && !core_1.Token.isUnresolved(limits.requestRateLimitMaximum) &&
+                limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&
+                limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {
+                throw new core_1.ValidationError('Request rate minimum cannot be greater than maximum', this);
+            }
         }
-        if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {
-            cacheUsageLimits.ecpuPerSecond = {
-                ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),
-                ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),
-            };
+        /**
+         * Validate backup settings meet AWS requirements
+         *
+         * @param backup The backup settings to validate
+         */
+        validateBackupSettings(backup) {
+            if (!core_1.Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {
+                const limit = backup.backupRetentionLimit;
+                if (limit < 1 || limit > 35) {
+                    throw new core_1.ValidationError('Backup retention limit must be between 1 and 35 days', this);
+                }
+            }
+            if (!core_1.Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {
+                const name = backup.backupNameBeforeDeletion;
+                if (!/^[a-zA-Z]/.test(name)) {
+                    throw new core_1.ValidationError('Final backup name must begin with a letter', this);
+                }
+                if (!/^[a-zA-Z0-9-]+$/.test(name)) {
+                    throw new core_1.ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);
+                }
+                if (name.endsWith('-')) {
+                    throw new core_1.ValidationError('Final backup name must not end with a hyphen', this);
+                }
+                if (name.includes('--')) {
+                    throw new core_1.ValidationError('Final backup name must not contain two consecutive hyphens', this);
+                }
+            }
         }
-        return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;
-    }
-    /**
-     * Configure subnets for the cache
-     *
-     * @param props The ServerlessCache properties
-     * @returns Object containing subnet IDs and subnet objects
-     */
-    configureSubnets(props) {
-        let selectedSubnets;
-        if (props.vpcSubnets) {
-            selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);
+        /**
+         * Validate user group compatibility with cache engine
+         *
+         * @param engine The cache engine
+         * @param userGroup The user group to validate
+         */
+        validateUserGroupCompatibility(engine, userGroup) {
+            if (!userGroup)
+                return;
+            if (engine === serverless_cache_base_1.CacheEngine.MEMCACHED_LATEST) {
+                throw new core_1.ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);
+            }
+            if (engine === serverless_cache_base_1.CacheEngine.REDIS_LATEST && userGroup.engine !== common_1.UserEngine.REDIS) {
+                throw new core_1.ValidationError('Redis cache can only use Redis user groups.', this);
+            }
         }
-        else {
-            selectedSubnets = props.vpc.selectSubnets({
-                subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
-            });
+        /**
+         * Render cache usage limits for CloudFormation
+         *
+         * @param limits The usage limits to render
+         * @returns CloudFormation-compatible usage limits object or undefined
+         */
+        renderCacheUsageLimits(limits) {
+            if (!limits)
+                return undefined;
+            const cacheUsageLimits = {};
+            if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {
+                cacheUsageLimits.dataStorage = {
+                    unit: DataStorageUnit.GIGABYTES,
+                    ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),
+                    ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),
+                };
+            }
+            if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {
+                cacheUsageLimits.ecpuPerSecond = {
+                    ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),
+                    ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),
+                };
+            }
+            return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;
         }
-        return {
-            subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,
-            subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,
-        };
-    }
-    /**
-     * Configure security groups for the cache
-     *
-     * @param props The ServerlessCache properties
-     * @returns Object containing security group IDs and security group objects
-     */
-    configureSecurityGroups(props) {
-        if (props.securityGroups && props.securityGroups.length > 0) {
+        /**
+         * Configure subnets for the cache
+         *
+         * @param props The ServerlessCache properties
+         * @returns Object containing subnet IDs and subnet objects
+         */
+        configureSubnets(props) {
+            let selectedSubnets;
+            if (props.vpcSubnets) {
+                selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);
+            }
+            else {
+                selectedSubnets = props.vpc.selectSubnets({
+                    subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
+                });
+            }
             return {
-                securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),
-                securityGroups: props.securityGroups,
+                subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,
+                subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,
             };
         }
-        else {
-            const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
-                description: `Security group for ${this.node.id} cache.`,
-                vpc: props.vpc,
-            });
-            return {
-                securityGroupIds: [newSecurityGroup.securityGroupId],
-                securityGroups: [newSecurityGroup],
-            };
+        /**
+         * Configure security groups for the cache
+         *
+         * @param props The ServerlessCache properties
+         * @returns Object containing security group IDs and security group objects
+         */
+        configureSecurityGroups(props) {
+            if (props.securityGroups && props.securityGroups.length > 0) {
+                return {
+                    securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),
+                    securityGroups: props.securityGroups,
+                };
+            }
+            else {
+                const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
+                    description: `Security group for ${this.node.id} cache.`,
+                    vpc: props.vpc,
+                });
+                return {
+                    securityGroupIds: [newSecurityGroup.securityGroupId],
+                    securityGroups: [newSecurityGroup],
+                };
+            }
         }
-    }
-    /**
-     * Format schedule to HH:MM format for daily backups
-     *
-     * @param schedule The schedule to format
-     * @returns Time string in HH:MM format
-     */
-    formatBackupTime(schedule) {
-        const WILD_CARD = '*';
-        const [minuteExpression, hourExpression, dayExpression, monthExpression, weekDayExpression, yearExpression,] = schedule.expressionString.substr(5).slice(0, -1).split(' ');
-        if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {
-            throw new core_1.ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);
+        /**
+         * Format schedule to HH:MM format for daily backups
+         *
+         * @param schedule The schedule to format
+         * @returns Time string in HH:MM format
+         */
+        formatBackupTime(schedule) {
+            const WILD_CARD = '*';
+            const [minuteExpression, hourExpression, dayExpression, monthExpression, weekDayExpression, yearExpression,] = schedule.expressionString.substr(5).slice(0, -1).split(' ');
+            if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {
+                throw new core_1.ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);
+            }
+            const hour = hourExpression == WILD_CARD ? '0' : hourExpression;
+            const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;
+            return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
         }
-        const hour = hourExpression == WILD_CARD ? '0' : hourExpression;
-        const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;
-        return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;
-    }
-};
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ServerlessCache = _classThis;
+})();
 exports.ServerlessCache = ServerlessCache;
-_a = JSII_RTTI_SYMBOL_1;
-ServerlessCache[_a] = { fqn: "@aws-cdk/aws-elasticache-alpha.ServerlessCache", version: "2.219.0-alpha.0" };
-/**
- * Uniquely identifies this class.
- */
-ServerlessCache.PROPERTY_INJECTION_ID = 'aws-cdk-lib.aws-elasticache.ServerlessCache';
-exports.ServerlessCache = ServerlessCache = ServerlessCache_1 = __decorate([
-    prop_injectable_1.propertyInjectable
-], ServerlessCache);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serverless-cache.js","sourceRoot":"","sources":["serverless-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { UserEngine } from './common';\nimport { CfnServerlessCache, CfnUserGroup } from 'aws-cdk-lib/aws-elasticache';\nimport { IServerlessCache, ServerlessCacheBase, CacheEngine } from './serverless-cache-base';\nimport { IUserGroup } from './user-group';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { ArnFormat, Stack, Size, Lazy, ValidationError, Names, Token } from 'aws-cdk-lib/core';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\n\nconst ELASTICACHE_SERVERLESSCACHE_SYMBOL = Symbol.for('@aws-cdk/aws-elasticache.ServerlessCache');\n\n/**\n * Unit types for data storage usage limits\n */\nenum DataStorageUnit {\n  /**\n   * Gigabytes\n   */\n  GIGABYTES = 'GB',\n}\n\n/**\n * Minimum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MIN_GB = 1;\n/**\n * Maximum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MAX_GB = 5000;\n/**\n * Minimum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MIN_ECPU = 1000;\n/**\n * Maximum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MAX_ECPU = 15000000;\n\n/**\n * Usage limits configuration for ServerlessCache\n */\nexport interface CacheUsageLimitsProperty {\n  /**\n   * Minimum data storage size (1 GB)\n   *\n   * @default - No minimum limit\n   */\n  readonly dataStorageMinimumSize?: Size;\n  /**\n   * Maximum data storage size (5000 GB)\n   *\n   * @default - No maximum limit\n   */\n  readonly dataStorageMaximumSize?: Size;\n  /**\n   * Minimum request rate limit (1000 ECPUs per second)\n   *\n   * @default - No minimum limit\n   */\n  readonly requestRateLimitMinimum?: number;\n  /**\n   * Maximum request rate limit (15000000 ECPUs per second)\n   *\n   * @default - No maximum limit\n   */\n  readonly requestRateLimitMaximum?: number;\n}\n\n/**\n * Backup configuration for ServerlessCache\n */\nexport interface BackupSettings {\n  /**\n   * Automated daily backup UTC time\n   *\n   * @default - No automated backups\n   */\n  readonly backupTime?: events.Schedule;\n  /**\n   * Number of days to retain backups (1-35)\n   *\n   * @default - Backups are not retained\n   */\n  readonly backupRetentionLimit?: number;\n  /**\n   * Name for the final backup taken before deletion\n   *\n   * @default - No final backup\n   */\n  readonly backupNameBeforeDeletion?: string;\n  /**\n   * ARNs of backups from which to restore data into the new cache\n   *\n   * @default - Create a new cache with no existing data\n   */\n  readonly backupArnsToRestore?: string[];\n}\n\n/**\n * Properties for defining a ServerlessCache\n */\nexport interface ServerlessCacheProps {\n  /**\n   * The cache engine combined with the version\n   * Enum options: VALKEY_DEFAULT, VALKEY_7, VALKEY_8, REDIS_DEFAULT, MEMCACHED_DEFAULT\n   * The default options bring the latest versions available.\n   *\n   * @default when not provided, the default engine would be Valkey, latest version available (VALKEY_DEFAULT)\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * Name for the serverless cache\n   *\n   * @default automatically generated name by Resource\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * A description for the cache\n   *\n   * @default - No description\n   */\n  readonly description?: string;\n  /**\n   * Usage limits for the cache\n   *\n   * @default - No usage limits\n   */\n  readonly cacheUsageLimits?: CacheUsageLimitsProperty;\n  /**\n   * Backup configuration\n   *\n   * @default - No backups configured\n   */\n  readonly backup?: BackupSettings;\n  /**\n   * KMS key for encryption\n   *\n   * @default - Service managed encryption (AWS owned KMS key)\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC to place the cache in\n   */\n  readonly vpc: ec2.IVpc;\n  /**\n   * Which subnets to place the cache in\n   *\n   * @default - Private subnets with egress\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n  /**\n   * Security groups for the cache\n   *\n   * @default - A new security group is created\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * User group for access control\n   *\n   * @default - No user group\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * Attributes that can be specified when importing a ServerlessCache\n */\nexport interface ServerlessCacheAttributes {\n  /**\n   * The cache engine used by this cache\n   *\n   * @default - engine type is unknown\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * The name of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheArn\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * The ARN of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheName\n   */\n  readonly serverlessCacheArn?: string;\n  /**\n   * The ARNs of backups restored in the cache\n   *\n   * @default - backups are unknown\n   */\n  readonly backupArnsToRestore?: string[];\n  /**\n   * The KMS key used for encryption\n   *\n   * @default - encryption key is unknown\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC this cache is deployed in\n   *\n   * @default - VPC is unknown\n   */\n  readonly vpc?: ec2.IVpc;\n  /**\n   * The subnets this cache is deployed in\n   *\n   * @default - subnets are unknown\n   */\n  readonly subnets?: ec2.ISubnet[];\n  /**\n   * The security groups associated with this cache\n   *\n   * @default - security groups are unknown\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * The user group associated with this cache\n   *\n   * @default - user group is unknown\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * A serverless ElastiCache cache\n *\n * @resource AWS::ElastiCache::ServerlessCache\n */\n@propertyInjectable\nexport class ServerlessCache extends ServerlessCacheBase {\n  /**\n   * Uniquely identifies this class.\n   */\n  public static readonly PROPERTY_INJECTION_ID: string = 'aws-cdk-lib.aws-elasticache.ServerlessCache';\n\n  /**\n   * Return whether the given object is a `ServerlessCache`\n   */\n  public static isServerlessCache(x: any): x is ServerlessCache {\n    return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;\n  }\n\n  /**\n   * Import an existing serverless cache by name\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheName The name of the existing serverless cache\n   */\n  public static fromServerlessCacheName(scope: Construct, id: string, serverlessCacheName: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });\n  }\n\n  /**\n   * Import an existing serverless cache by ARN\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheArn The ARN of the existing serverless cache\n   */\n  public static fromServerlessCacheArn(scope: Construct, id: string, serverlessCacheArn: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });\n  }\n\n  /**\n   * Import an existing serverless cache using attributes\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param attrs A `ServerlessCacheAttributes` object\n   */\n  public static fromServerlessCacheAttributes(scope: Construct, id: string, attrs: ServerlessCacheAttributes): IServerlessCache {\n    let name: string;\n    let arn: string;\n    const stack = Stack.of(scope);\n\n    if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {\n      throw new ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);\n    }\n\n    if (attrs.serverlessCacheArn) {\n      arn = attrs.serverlessCacheArn;\n      const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName;\n      if (!extractedServerlessCacheName) {\n        throw new ValidationError('Unable to extract serverless cache name from ARN.', scope);\n      }\n      name = extractedServerlessCacheName;\n    } else if (attrs.serverlessCacheName) {\n      name = attrs.serverlessCacheName;\n      arn = stack.formatArn({\n        service: 'elasticache',\n        resource: 'serverlesscache',\n        resourceName: attrs.serverlessCacheName,\n      });\n    } else {\n      throw new ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);\n    }\n\n    class Import extends ServerlessCacheBase {\n      public readonly engine = attrs.engine;\n      public readonly serverlessCacheName: string;\n      public readonly serverlessCacheArn: string;\n      public readonly backupArnsToRestore = attrs.backupArnsToRestore;\n      public readonly kmsKey = attrs.kmsKey;\n      public readonly vpc = attrs.vpc;\n      public readonly subnets = attrs.subnets;\n      public readonly securityGroups = attrs.securityGroups;\n      public readonly userGroup = attrs.userGroup;\n\n      public readonly connections: ec2.Connections;\n\n      constructor(serverlessCacheArn: string, serverlessCacheName: string) {\n        super(scope, id);\n        this.serverlessCacheArn = serverlessCacheArn;\n        this.serverlessCacheName = serverlessCacheName;\n\n        if (this.engine) {\n          let defaultPort: ec2.Port;\n          switch (this.engine) {\n            case CacheEngine.VALKEY_LATEST:\n            case CacheEngine.VALKEY_7:\n            case CacheEngine.VALKEY_8:\n            case CacheEngine.REDIS_LATEST:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(6379);\n              break;\n            case CacheEngine.MEMCACHED_LATEST:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(11211);\n              break;\n            default:\n              throw new ValidationError(`Unsupported cache engine: ${this.engine}`, scope);\n          }\n\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n            defaultPort: defaultPort,\n          });\n        } else {\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n          });\n        }\n      }\n    }\n\n    return new Import(arn, name);\n  }\n\n  public readonly engine?: CacheEngine;\n  public readonly serverlessCacheName: string;\n  public readonly backupArnsToRestore?: string[];\n  public readonly kmsKey?: kms.IKey;\n  public readonly vpc?: ec2.IVpc;\n  public readonly subnets?: ec2.ISubnet[];\n  public readonly securityGroups?: ec2.ISecurityGroup[];\n  public readonly userGroup?: IUserGroup;\n\n  /**\n   * The ARN of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheArn: string;\n  /**\n   * The endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointAddress: string;\n  /**\n   * The endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointPort: string;\n  /**\n   * The reader endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointAddress: string;\n  /**\n   * The reader endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointPort: string;\n  /**\n   * The current status of the serverless cache\n   * Can be 'CREATING', 'AVAILABLE', 'DELETING', 'CREATE-FAILED', 'MODIFYING'\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheStatus: string;\n\n  /**\n   * Access to network connections\n   */\n  public readonly connections: ec2.Connections;\n\n  constructor(scope: Construct, id: string, props: ServerlessCacheProps) {\n    super(scope, id, {});\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.engine = props.engine ?? CacheEngine.VALKEY_LATEST;\n    this.serverlessCacheName = props.serverlessCacheName ?? Lazy.string({ produce: () => Names.uniqueId(this) });\n    this.kmsKey = props.kmsKey;\n    this.vpc = props.vpc;\n    this.userGroup = props.userGroup;\n\n    this.validateDescription(props.description);\n    this.validateDataStorageLimits(props.cacheUsageLimits);\n    this.validateRequestRateLimits(props.cacheUsageLimits);\n    this.validateBackupSettings(props.backup);\n    this.validateUserGroupCompatibility(this.engine, this.userGroup);\n\n    const subnetConfig = this.configureSubnets(props);\n    const subnetIds = subnetConfig.subnetIds;\n    this.subnets = subnetConfig.subnets;\n\n    const securityGroupConfig = this.configureSecurityGroups(props);\n    const securityGroupIds = securityGroupConfig.securityGroupIds;\n    this.securityGroups = securityGroupConfig.securityGroups;\n\n    const [engine, version] = this.engine.split('_');\n\n    const resource = new CfnServerlessCache(this, 'Resource', {\n      engine: engine,\n      majorEngineVersion: version,\n      serverlessCacheName: this.serverlessCacheName,\n      description: props.description,\n      cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),\n      dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,\n      snapshotRetentionLimit: props.backup?.backupRetentionLimit,\n      finalSnapshotName: props.backup?.backupNameBeforeDeletion,\n      snapshotArnsToRestore: props.backup?.backupArnsToRestore,\n      kmsKeyId: props.kmsKey?.keyId,\n      subnetIds: subnetIds,\n      securityGroupIds: securityGroupIds,\n      userGroupId: props.userGroup?.userGroupName,\n    });\n\n    if (props.userGroup) {\n      const userGroupResource = props.userGroup.node.findChild('Resource') as CfnUserGroup;\n      resource.addDependency(userGroupResource);\n    }\n\n    this.backupArnsToRestore = resource.snapshotArnsToRestore;\n    this.serverlessCacheArn = resource.attrArn;\n    this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;\n    this.serverlessCacheEndpointPort = resource.attrEndpointPort;\n    this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;\n    this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;\n    this.serverlessCacheStatus = resource.attrStatus;\n\n    this.connections = new ec2.Connections({\n      securityGroups: this.securityGroups,\n      defaultPort: ec2.Port.tcp(Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),\n    });\n\n    Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });\n  }\n\n  /**\n   * Validate description meets AWS requirements\n   *\n   * @param description The description to validate\n   */\n  private validateDescription(description?: string): void {\n    if (!description || Token.isUnresolved(description)) return;\n\n    if (description.length > 255) {\n      throw new ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);\n    }\n\n    if (description.includes('<') || description.includes('>')) {\n      throw new ValidationError('Description must not contain < or > characters', this);\n    }\n  }\n\n  /**\n   * Validate data storage size limits\n   *\n   * @param limits The usage limits containing data storage settings\n   */\n  private validateDataStorageLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&\n      (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);\n    }\n    if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&\n      (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);\n    }\n\n    if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&\n      !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&\n      limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {\n      throw new ValidationError('Data storage minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate request rate limits\n   *\n   * @param limits The usage limits containing request rate settings\n   */\n  private validateRequestRateLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.requestRateLimitMinimum !== undefined && !Token.isUnresolved(limits.requestRateLimitMinimum) &&\n      (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n    if (limits.requestRateLimitMaximum !== undefined && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n\n    if (!Token.isUnresolved(limits.requestRateLimitMinimum) && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&\n      limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {\n      throw new ValidationError('Request rate minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate backup settings meet AWS requirements\n   *\n   * @param backup The backup settings to validate\n   */\n  private validateBackupSettings(backup?: BackupSettings): void {\n    if (!Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {\n      const limit = backup.backupRetentionLimit;\n      if (limit < 1 || limit > 35) {\n        throw new ValidationError('Backup retention limit must be between 1 and 35 days', this);\n      }\n    }\n\n    if (!Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {\n      const name = backup.backupNameBeforeDeletion;\n\n      if (!/^[a-zA-Z]/.test(name)) {\n        throw new ValidationError('Final backup name must begin with a letter', this);\n      }\n\n      if (!/^[a-zA-Z0-9-]+$/.test(name)) {\n        throw new ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);\n      }\n\n      if (name.endsWith('-')) {\n        throw new ValidationError('Final backup name must not end with a hyphen', this);\n      }\n\n      if (name.includes('--')) {\n        throw new ValidationError('Final backup name must not contain two consecutive hyphens', this);\n      }\n    }\n  }\n\n  /**\n   * Validate user group compatibility with cache engine\n   *\n   * @param engine The cache engine\n   * @param userGroup The user group to validate\n   */\n  private validateUserGroupCompatibility(engine: CacheEngine, userGroup?: IUserGroup): void {\n    if (!userGroup) return;\n\n    if (engine === CacheEngine.MEMCACHED_LATEST) {\n      throw new ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);\n    }\n\n    if (engine === CacheEngine.REDIS_LATEST && userGroup.engine !== UserEngine.REDIS) {\n      throw new ValidationError('Redis cache can only use Redis user groups.', this);\n    }\n  }\n\n  /**\n   * Render cache usage limits for CloudFormation\n   *\n   * @param limits The usage limits to render\n   * @returns CloudFormation-compatible usage limits object or undefined\n   */\n  private renderCacheUsageLimits(limits?: CacheUsageLimitsProperty): any {\n    if (!limits) return undefined;\n\n    const cacheUsageLimits: any = {};\n\n    if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {\n      cacheUsageLimits.dataStorage = {\n        unit: DataStorageUnit.GIGABYTES,\n        ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),\n        ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),\n      };\n    }\n\n    if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {\n      cacheUsageLimits.ecpuPerSecond = {\n        ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),\n        ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),\n      };\n    }\n\n    return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;\n  }\n\n  /**\n   * Configure subnets for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing subnet IDs and subnet objects\n   */\n  private configureSubnets(props: ServerlessCacheProps): { subnetIds: string[] | undefined; subnets: ec2.ISubnet[] | undefined } {\n    let selectedSubnets;\n    if (props.vpcSubnets) {\n      selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);\n    } else {\n      selectedSubnets = props.vpc.selectSubnets({\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n      });\n    }\n\n    return {\n      subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,\n      subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,\n    };\n  }\n\n  /**\n   * Configure security groups for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing security group IDs and security group objects\n   */\n  private configureSecurityGroups(props: ServerlessCacheProps): { securityGroupIds: string[]; securityGroups: ec2.ISecurityGroup[] } {\n    if (props.securityGroups && props.securityGroups.length > 0) {\n      return {\n        securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),\n        securityGroups: props.securityGroups,\n      };\n    } else {\n      const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {\n        description: `Security group for ${this.node.id} cache.`,\n        vpc: props.vpc,\n      });\n      return {\n        securityGroupIds: [newSecurityGroup.securityGroupId],\n        securityGroups: [newSecurityGroup],\n      };\n    }\n  }\n\n  /**\n   * Format schedule to HH:MM format for daily backups\n   *\n   * @param schedule The schedule to format\n   * @returns Time string in HH:MM format\n   */\n  private formatBackupTime(schedule: events.Schedule): string {\n    const WILD_CARD = '*';\n    const [\n      minuteExpression, hourExpression,\n      dayExpression, monthExpression,\n      weekDayExpression, yearExpression,\n    ] = schedule.expressionString.substr(5).slice(0, -1).split(' ');\n\n    if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {\n      throw new ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);\n    }\n\n    const hour = hourExpression == WILD_CARD ? '0' : hourExpression;\n    const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;\n\n    return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serverless-cache.js","sourceRoot":"","sources":["serverless-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { UserEngine } from './common';\nimport { CfnServerlessCache, CfnUserGroup } from 'aws-cdk-lib/aws-elasticache';\nimport { IServerlessCache, ServerlessCacheBase, CacheEngine } from './serverless-cache-base';\nimport { IUserGroup } from './user-group';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { ArnFormat, Stack, Size, Lazy, ValidationError, Names, Token } from 'aws-cdk-lib/core';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\n\nconst ELASTICACHE_SERVERLESSCACHE_SYMBOL = Symbol.for('@aws-cdk/aws-elasticache.ServerlessCache');\n\n/**\n * Unit types for data storage usage limits\n */\nenum DataStorageUnit {\n  /**\n   * Gigabytes\n   */\n  GIGABYTES = 'GB',\n}\n\n/**\n * Minimum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MIN_GB = 1;\n/**\n * Maximum data storage size in GB for ServerlessCache\n */\nconst DATA_STORAGE_MAX_GB = 5000;\n/**\n * Minimum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MIN_ECPU = 1000;\n/**\n * Maximum request rate limit in ECPUs per second for ServerlessCache\n */\nconst REQUEST_RATE_MAX_ECPU = 15000000;\n\n/**\n * Usage limits configuration for ServerlessCache\n */\nexport interface CacheUsageLimitsProperty {\n  /**\n   * Minimum data storage size (1 GB)\n   *\n   * @default - No minimum limit\n   */\n  readonly dataStorageMinimumSize?: Size;\n  /**\n   * Maximum data storage size (5000 GB)\n   *\n   * @default - No maximum limit\n   */\n  readonly dataStorageMaximumSize?: Size;\n  /**\n   * Minimum request rate limit (1000 ECPUs per second)\n   *\n   * @default - No minimum limit\n   */\n  readonly requestRateLimitMinimum?: number;\n  /**\n   * Maximum request rate limit (15000000 ECPUs per second)\n   *\n   * @default - No maximum limit\n   */\n  readonly requestRateLimitMaximum?: number;\n}\n\n/**\n * Backup configuration for ServerlessCache\n */\nexport interface BackupSettings {\n  /**\n   * Automated daily backup UTC time\n   *\n   * @default - No automated backups\n   */\n  readonly backupTime?: events.Schedule;\n  /**\n   * Number of days to retain backups (1-35)\n   *\n   * @default - Backups are not retained\n   */\n  readonly backupRetentionLimit?: number;\n  /**\n   * Name for the final backup taken before deletion\n   *\n   * @default - No final backup\n   */\n  readonly backupNameBeforeDeletion?: string;\n  /**\n   * ARNs of backups from which to restore data into the new cache\n   *\n   * @default - Create a new cache with no existing data\n   */\n  readonly backupArnsToRestore?: string[];\n}\n\n/**\n * Properties for defining a ServerlessCache\n */\nexport interface ServerlessCacheProps {\n  /**\n   * The cache engine combined with the version\n   * Enum options: VALKEY_DEFAULT, VALKEY_7, VALKEY_8, REDIS_DEFAULT, MEMCACHED_DEFAULT\n   * The default options bring the latest versions available.\n   *\n   * @default when not provided, the default engine would be Valkey, latest version available (VALKEY_DEFAULT)\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * Name for the serverless cache\n   *\n   * @default automatically generated name by Resource\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * A description for the cache\n   *\n   * @default - No description\n   */\n  readonly description?: string;\n  /**\n   * Usage limits for the cache\n   *\n   * @default - No usage limits\n   */\n  readonly cacheUsageLimits?: CacheUsageLimitsProperty;\n  /**\n   * Backup configuration\n   *\n   * @default - No backups configured\n   */\n  readonly backup?: BackupSettings;\n  /**\n   * KMS key for encryption\n   *\n   * @default - Service managed encryption (AWS owned KMS key)\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC to place the cache in\n   */\n  readonly vpc: ec2.IVpc;\n  /**\n   * Which subnets to place the cache in\n   *\n   * @default - Private subnets with egress\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n  /**\n   * Security groups for the cache\n   *\n   * @default - A new security group is created\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * User group for access control\n   *\n   * @default - No user group\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * Attributes that can be specified when importing a ServerlessCache\n */\nexport interface ServerlessCacheAttributes {\n  /**\n   * The cache engine used by this cache\n   *\n   * @default - engine type is unknown\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * The name of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheArn\n   */\n  readonly serverlessCacheName?: string;\n  /**\n   * The ARN of the serverless cache\n   *\n   * One of `serverlessCacheName` or `serverlessCacheArn` is required.\n   *\n   * @default - derived from serverlessCacheName\n   */\n  readonly serverlessCacheArn?: string;\n  /**\n   * The ARNs of backups restored in the cache\n   *\n   * @default - backups are unknown\n   */\n  readonly backupArnsToRestore?: string[];\n  /**\n   * The KMS key used for encryption\n   *\n   * @default - encryption key is unknown\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC this cache is deployed in\n   *\n   * @default - VPC is unknown\n   */\n  readonly vpc?: ec2.IVpc;\n  /**\n   * The subnets this cache is deployed in\n   *\n   * @default - subnets are unknown\n   */\n  readonly subnets?: ec2.ISubnet[];\n  /**\n   * The security groups associated with this cache\n   *\n   * @default - security groups are unknown\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * The user group associated with this cache\n   *\n   * @default - user group is unknown\n   */\n  readonly userGroup?: IUserGroup;\n}\n\n/**\n * A serverless ElastiCache cache\n *\n * @resource AWS::ElastiCache::ServerlessCache\n */\n@propertyInjectable\nexport class ServerlessCache extends ServerlessCacheBase {\n  /**\n   * Uniquely identifies this class.\n   */\n  public static readonly PROPERTY_INJECTION_ID: string = 'aws-cdk-lib.aws-elasticache.ServerlessCache';\n\n  /**\n   * Return whether the given object is a `ServerlessCache`\n   */\n  public static isServerlessCache(x: any): x is ServerlessCache {\n    return x !== null && typeof (x) === 'object' && ELASTICACHE_SERVERLESSCACHE_SYMBOL in x;\n  }\n\n  /**\n   * Import an existing serverless cache by name\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheName The name of the existing serverless cache\n   */\n  public static fromServerlessCacheName(scope: Construct, id: string, serverlessCacheName: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheName });\n  }\n\n  /**\n   * Import an existing serverless cache by ARN\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param serverlessCacheArn The ARN of the existing serverless cache\n   */\n  public static fromServerlessCacheArn(scope: Construct, id: string, serverlessCacheArn: string): IServerlessCache {\n    return ServerlessCache.fromServerlessCacheAttributes(scope, id, { serverlessCacheArn });\n  }\n\n  /**\n   * Import an existing serverless cache using attributes\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param attrs A `ServerlessCacheAttributes` object\n   */\n  public static fromServerlessCacheAttributes(scope: Construct, id: string, attrs: ServerlessCacheAttributes): IServerlessCache {\n    let name: string;\n    let arn: string;\n    const stack = Stack.of(scope);\n\n    if (attrs.serverlessCacheArn && attrs.serverlessCacheName) {\n      throw new ValidationError('Only one of serverlessCacheArn or serverlessCacheName can be provided.', scope);\n    }\n\n    if (attrs.serverlessCacheArn) {\n      arn = attrs.serverlessCacheArn;\n      const extractedServerlessCacheName = stack.splitArn(attrs.serverlessCacheArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName;\n      if (!extractedServerlessCacheName) {\n        throw new ValidationError('Unable to extract serverless cache name from ARN.', scope);\n      }\n      name = extractedServerlessCacheName;\n    } else if (attrs.serverlessCacheName) {\n      name = attrs.serverlessCacheName;\n      arn = stack.formatArn({\n        service: 'elasticache',\n        resource: 'serverlesscache',\n        resourceName: attrs.serverlessCacheName,\n      });\n    } else {\n      throw new ValidationError('One of serverlessCacheName or serverlessCacheArn is required.', scope);\n    }\n\n    class Import extends ServerlessCacheBase {\n      public readonly engine = attrs.engine;\n      public readonly serverlessCacheName: string;\n      public readonly serverlessCacheArn: string;\n      public readonly backupArnsToRestore = attrs.backupArnsToRestore;\n      public readonly kmsKey = attrs.kmsKey;\n      public readonly vpc = attrs.vpc;\n      public readonly subnets = attrs.subnets;\n      public readonly securityGroups = attrs.securityGroups;\n      public readonly userGroup = attrs.userGroup;\n\n      public readonly connections: ec2.Connections;\n\n      constructor(serverlessCacheArn: string, serverlessCacheName: string) {\n        super(scope, id);\n        this.serverlessCacheArn = serverlessCacheArn;\n        this.serverlessCacheName = serverlessCacheName;\n\n        if (this.engine) {\n          let defaultPort: ec2.Port;\n          switch (this.engine) {\n            case CacheEngine.VALKEY_LATEST:\n            case CacheEngine.VALKEY_7:\n            case CacheEngine.VALKEY_8:\n            case CacheEngine.REDIS_LATEST:\n            case CacheEngine.REDIS_7:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(6379);\n              break;\n            case CacheEngine.MEMCACHED_LATEST:\n              // Document showing the default port\n              // https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/set-up.html#elasticache-install-grant-access-VPN\n              defaultPort = ec2.Port.tcp(11211);\n              break;\n            default:\n              throw new ValidationError(`Unsupported cache engine: ${this.engine}`, scope);\n          }\n\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n            defaultPort: defaultPort,\n          });\n        } else {\n          this.connections = new ec2.Connections({\n            securityGroups: this.securityGroups,\n          });\n        }\n      }\n    }\n\n    return new Import(arn, name);\n  }\n\n  public readonly engine?: CacheEngine;\n  public readonly serverlessCacheName: string;\n  public readonly backupArnsToRestore?: string[];\n  public readonly kmsKey?: kms.IKey;\n  public readonly vpc?: ec2.IVpc;\n  public readonly subnets?: ec2.ISubnet[];\n  public readonly securityGroups?: ec2.ISecurityGroup[];\n  public readonly userGroup?: IUserGroup;\n\n  /**\n   * The ARN of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheArn: string;\n  /**\n   * The endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointAddress: string;\n  /**\n   * The endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheEndpointPort: string;\n  /**\n   * The reader endpoint address of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointAddress: string;\n  /**\n   * The reader endpoint port of the serverless cache\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheReaderEndpointPort: string;\n  /**\n   * The current status of the serverless cache\n   * Can be 'CREATING', 'AVAILABLE', 'DELETING', 'CREATE-FAILED', 'MODIFYING'\n   *\n   * @attribute\n   */\n  public readonly serverlessCacheStatus: string;\n\n  /**\n   * Access to network connections\n   */\n  public readonly connections: ec2.Connections;\n\n  constructor(scope: Construct, id: string, props: ServerlessCacheProps) {\n    super(scope, id, {});\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.engine = props.engine ?? CacheEngine.VALKEY_LATEST;\n    this.serverlessCacheName = props.serverlessCacheName ?? Lazy.string({ produce: () => Names.uniqueId(this) });\n    this.kmsKey = props.kmsKey;\n    this.vpc = props.vpc;\n    this.userGroup = props.userGroup;\n\n    this.validateDescription(props.description);\n    this.validateDataStorageLimits(props.cacheUsageLimits);\n    this.validateRequestRateLimits(props.cacheUsageLimits);\n    this.validateBackupSettings(props.backup);\n    this.validateUserGroupCompatibility(this.engine, this.userGroup);\n\n    const subnetConfig = this.configureSubnets(props);\n    const subnetIds = subnetConfig.subnetIds;\n    this.subnets = subnetConfig.subnets;\n\n    const securityGroupConfig = this.configureSecurityGroups(props);\n    const securityGroupIds = securityGroupConfig.securityGroupIds;\n    this.securityGroups = securityGroupConfig.securityGroups;\n\n    const [engine, version] = this.engine.split('_');\n\n    const resource = new CfnServerlessCache(this, 'Resource', {\n      engine: engine,\n      majorEngineVersion: version,\n      serverlessCacheName: this.serverlessCacheName,\n      description: props.description,\n      cacheUsageLimits: this.renderCacheUsageLimits(props.cacheUsageLimits),\n      dailySnapshotTime: props.backup?.backupTime ? this.formatBackupTime(props.backup.backupTime) : undefined,\n      snapshotRetentionLimit: props.backup?.backupRetentionLimit,\n      finalSnapshotName: props.backup?.backupNameBeforeDeletion,\n      snapshotArnsToRestore: props.backup?.backupArnsToRestore,\n      kmsKeyId: props.kmsKey?.keyId,\n      subnetIds: subnetIds,\n      securityGroupIds: securityGroupIds,\n      userGroupId: props.userGroup?.userGroupName,\n    });\n\n    if (props.userGroup) {\n      const userGroupResource = props.userGroup.node.findChild('Resource') as CfnUserGroup;\n      resource.addDependency(userGroupResource);\n    }\n\n    this.backupArnsToRestore = resource.snapshotArnsToRestore;\n    this.serverlessCacheArn = resource.attrArn;\n    this.serverlessCacheEndpointAddress = resource.attrEndpointAddress;\n    this.serverlessCacheEndpointPort = resource.attrEndpointPort;\n    this.serverlessCacheReaderEndpointAddress = resource.attrReaderEndpointAddress;\n    this.serverlessCacheReaderEndpointPort = resource.attrReaderEndpointPort;\n    this.serverlessCacheStatus = resource.attrStatus;\n\n    this.connections = new ec2.Connections({\n      securityGroups: this.securityGroups,\n      defaultPort: ec2.Port.tcp(Lazy.number({ produce: () => parseInt(this.serverlessCacheEndpointPort) })),\n    });\n\n    Object.defineProperty(this, ELASTICACHE_SERVERLESSCACHE_SYMBOL, { value: true });\n  }\n\n  /**\n   * Validate description meets AWS requirements\n   *\n   * @param description The description to validate\n   */\n  private validateDescription(description?: string): void {\n    if (!description || Token.isUnresolved(description)) return;\n\n    if (description.length > 255) {\n      throw new ValidationError(`Description must not exceed 255 characters, currently has ${description.length}`, this);\n    }\n\n    if (description.includes('<') || description.includes('>')) {\n      throw new ValidationError('Description must not contain < or > characters', this);\n    }\n  }\n\n  /**\n   * Validate data storage size limits\n   *\n   * @param limits The usage limits containing data storage settings\n   */\n  private validateDataStorageLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.dataStorageMinimumSize && !limits.dataStorageMinimumSize.isUnresolved() &&\n      (limits.dataStorageMinimumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMinimumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage minimum must be between 1 and 5000 GB.', this);\n    }\n    if (limits.dataStorageMaximumSize && !limits.dataStorageMaximumSize.isUnresolved() &&\n      (limits.dataStorageMaximumSize.toGibibytes() < DATA_STORAGE_MIN_GB || limits.dataStorageMaximumSize.toGibibytes() > DATA_STORAGE_MAX_GB)) {\n      throw new ValidationError('Data storage maximum must be between 1 and 5000 GB.', this);\n    }\n\n    if (limits.dataStorageMinimumSize && limits.dataStorageMaximumSize &&\n      !limits.dataStorageMinimumSize.isUnresolved() && !limits.dataStorageMaximumSize.isUnresolved() &&\n      limits.dataStorageMinimumSize.toGibibytes() > limits.dataStorageMaximumSize.toGibibytes()) {\n      throw new ValidationError('Data storage minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate request rate limits\n   *\n   * @param limits The usage limits containing request rate settings\n   */\n  private validateRequestRateLimits(limits?: CacheUsageLimitsProperty): void {\n    if (!limits) return;\n\n    if (limits.requestRateLimitMinimum !== undefined && !Token.isUnresolved(limits.requestRateLimitMinimum) &&\n      (limits.requestRateLimitMinimum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMinimum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate minimum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n    if (limits.requestRateLimitMaximum !== undefined && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      (limits.requestRateLimitMaximum < REQUEST_RATE_MIN_ECPU || limits.requestRateLimitMaximum > REQUEST_RATE_MAX_ECPU)) {\n      throw new ValidationError('Request rate maximum must be between 1,000 and 15,000,000 ECPUs per second', this);\n    }\n\n    if (!Token.isUnresolved(limits.requestRateLimitMinimum) && !Token.isUnresolved(limits.requestRateLimitMaximum) &&\n      limits.requestRateLimitMinimum !== undefined && limits.requestRateLimitMaximum !== undefined &&\n      limits.requestRateLimitMinimum > limits.requestRateLimitMaximum) {\n      throw new ValidationError('Request rate minimum cannot be greater than maximum', this);\n    }\n  }\n\n  /**\n   * Validate backup settings meet AWS requirements\n   *\n   * @param backup The backup settings to validate\n   */\n  private validateBackupSettings(backup?: BackupSettings): void {\n    if (!Token.isUnresolved(backup?.backupRetentionLimit) && backup?.backupRetentionLimit !== undefined) {\n      const limit = backup.backupRetentionLimit;\n      if (limit < 1 || limit > 35) {\n        throw new ValidationError('Backup retention limit must be between 1 and 35 days', this);\n      }\n    }\n\n    if (!Token.isUnresolved(backup?.backupNameBeforeDeletion) && backup?.backupNameBeforeDeletion !== undefined) {\n      const name = backup.backupNameBeforeDeletion;\n\n      if (!/^[a-zA-Z]/.test(name)) {\n        throw new ValidationError('Final backup name must begin with a letter', this);\n      }\n\n      if (!/^[a-zA-Z0-9-]+$/.test(name)) {\n        throw new ValidationError('Final backup name must contain only ASCII letters, digits, and hyphens', this);\n      }\n\n      if (name.endsWith('-')) {\n        throw new ValidationError('Final backup name must not end with a hyphen', this);\n      }\n\n      if (name.includes('--')) {\n        throw new ValidationError('Final backup name must not contain two consecutive hyphens', this);\n      }\n    }\n  }\n\n  /**\n   * Validate user group compatibility with cache engine\n   *\n   * @param engine The cache engine\n   * @param userGroup The user group to validate\n   */\n  private validateUserGroupCompatibility(engine: CacheEngine, userGroup?: IUserGroup): void {\n    if (!userGroup) return;\n\n    if (engine === CacheEngine.MEMCACHED_LATEST) {\n      throw new ValidationError('User groups cannot be used with Memcached engines. Only Redis and Valkey engines support user groups.', this);\n    }\n\n    if (engine === CacheEngine.REDIS_LATEST && userGroup.engine !== UserEngine.REDIS) {\n      throw new ValidationError('Redis cache can only use Redis user groups.', this);\n    }\n  }\n\n  /**\n   * Render cache usage limits for CloudFormation\n   *\n   * @param limits The usage limits to render\n   * @returns CloudFormation-compatible usage limits object or undefined\n   */\n  private renderCacheUsageLimits(limits?: CacheUsageLimitsProperty): any {\n    if (!limits) return undefined;\n\n    const cacheUsageLimits: any = {};\n\n    if (limits.dataStorageMinimumSize !== undefined || limits.dataStorageMaximumSize !== undefined) {\n      cacheUsageLimits.dataStorage = {\n        unit: DataStorageUnit.GIGABYTES,\n        ...(limits.dataStorageMinimumSize !== undefined && { minimum: limits.dataStorageMinimumSize.toGibibytes() }),\n        ...(limits.dataStorageMaximumSize !== undefined && { maximum: limits.dataStorageMaximumSize.toGibibytes() }),\n      };\n    }\n\n    if (limits.requestRateLimitMinimum !== undefined || limits.requestRateLimitMaximum !== undefined) {\n      cacheUsageLimits.ecpuPerSecond = {\n        ...(limits.requestRateLimitMinimum !== undefined && { minimum: limits.requestRateLimitMinimum }),\n        ...(limits.requestRateLimitMaximum !== undefined && { maximum: limits.requestRateLimitMaximum }),\n      };\n    }\n\n    return Object.keys(cacheUsageLimits).length > 0 ? cacheUsageLimits : undefined;\n  }\n\n  /**\n   * Configure subnets for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing subnet IDs and subnet objects\n   */\n  private configureSubnets(props: ServerlessCacheProps): { subnetIds: string[] | undefined; subnets: ec2.ISubnet[] | undefined } {\n    let selectedSubnets;\n    if (props.vpcSubnets) {\n      selectedSubnets = props.vpc.selectSubnets(props.vpcSubnets);\n    } else {\n      selectedSubnets = props.vpc.selectSubnets({\n        subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n      });\n    }\n\n    return {\n      subnetIds: selectedSubnets.subnetIds.length > 0 ? selectedSubnets.subnetIds : undefined,\n      subnets: selectedSubnets.subnets.length > 0 ? selectedSubnets.subnets : undefined,\n    };\n  }\n\n  /**\n   * Configure security groups for the cache\n   *\n   * @param props The ServerlessCache properties\n   * @returns Object containing security group IDs and security group objects\n   */\n  private configureSecurityGroups(props: ServerlessCacheProps): { securityGroupIds: string[]; securityGroups: ec2.ISecurityGroup[] } {\n    if (props.securityGroups && props.securityGroups.length > 0) {\n      return {\n        securityGroupIds: props.securityGroups.map(sg => sg.securityGroupId),\n        securityGroups: props.securityGroups,\n      };\n    } else {\n      const newSecurityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {\n        description: `Security group for ${this.node.id} cache.`,\n        vpc: props.vpc,\n      });\n      return {\n        securityGroupIds: [newSecurityGroup.securityGroupId],\n        securityGroups: [newSecurityGroup],\n      };\n    }\n  }\n\n  /**\n   * Format schedule to HH:MM format for daily backups\n   *\n   * @param schedule The schedule to format\n   * @returns Time string in HH:MM format\n   */\n  private formatBackupTime(schedule: events.Schedule): string {\n    const WILD_CARD = '*';\n    const [\n      minuteExpression, hourExpression,\n      dayExpression, monthExpression,\n      weekDayExpression, yearExpression,\n    ] = schedule.expressionString.substr(5).slice(0, -1).split(' ');\n\n    if (dayExpression != WILD_CARD || monthExpression != WILD_CARD || yearExpression != WILD_CARD || weekDayExpression != '?') {\n      throw new ValidationError('For now, only daily backup time is available (supports just hour and minute). Day, month, year, and weekDay are not allowed', this);\n    }\n\n    const hour = hourExpression == WILD_CARD ? '0' : hourExpression;\n    const minute = minuteExpression == WILD_CARD ? '0' : minuteExpression;\n\n    return `${hour.padStart(2, '0')}:${minute.padStart(2, '0')}`;\n  }\n}\n"]}