@aws-cdk/aws-elasticache-alpha 2.218.0-alpha.0

package/lib/serverless-cache-base.js

@@ -0,0 +1,183 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerlessCacheBase = exports.CacheEngine = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const iam = require("aws-cdk-lib/aws-iam");
+const core_1 = require("aws-cdk-lib/core");
+/**
+ * Supported cache engines together with available versions.
+ */
+var CacheEngine;
+(function (CacheEngine) {
+    /**
+     * Valkey engine, latest major version available, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["VALKEY_LATEST"] = "valkey";
+    /**
+     * Valkey engine, major version 7, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["VALKEY_7"] = "valkey_7";
+    /**
+     * Valkey engine, major version 8, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["VALKEY_8"] = "valkey_8";
+    /**
+     * Redis engine, latest major version available, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["REDIS_LATEST"] = "redis";
+    /**
+     * Redis engine, major version 7, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["REDIS_7"] = "redis_7";
+    /**
+     * Memcached engine, latest major version available, minor version is selected automatically
+     * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html
+     */
+    CacheEngine["MEMCACHED_LATEST"] = "memcached";
+})(CacheEngine || (exports.CacheEngine = CacheEngine = {}));
+/**
+ * Base class for ServerlessCache constructs
+ */
+class ServerlessCacheBase extends core_1.Resource {
+    /**
+     * Grant connect permissions to the cache
+     *
+     * @param grantee The principal to grant permissions to
+     */
+    grantConnect(grantee) {
+        return this.grant(grantee, 'elasticache:Connect', 'elasticache:DescribeServerlessCaches');
+    }
+    /**
+     * Grant the given identity custom permissions
+     *
+     * @param grantee The principal to grant permissions to
+     * @param actions The actions to grant
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.serverlessCacheArn],
+        });
+    }
+    /**
+     * Return the given named metric for this cache
+     *
+     * @param metricName The name of the metric
+     * @param props Additional properties which will be merged with the default metric
+     * @default Average over 5 minutes
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: 'AWS/ElastiCache',
+            metricName,
+            dimensionsMap: {
+                ServerlessCacheName: this.serverlessCacheName,
+            },
+            period: core_1.Duration.minutes(5),
+            statistic: 'Average',
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Metric for cache hit count
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Sum over 5 minutes
+     */
+    metricCacheHitCount(props) {
+        return this.metric('CacheHits', { statistic: 'Sum', ...props });
+    }
+    /**
+     * Metric for cache miss count
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Sum over 5 minutes
+     */
+    metricCacheMissCount(props) {
+        return this.metric('CacheMisses', { statistic: 'Sum', ...props });
+    }
+    /**
+     * Metric for cache hit rate
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Average over 5 minutes
+     */
+    metricCacheHitRate(props) {
+        return this.metric('CacheHitRate', props);
+    }
+    /**
+     * Metric for data stored in the cache
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Maximum over 5 minutes
+     */
+    metricDataStored(props) {
+        return this.metric('BytesUsedForCache', { statistic: 'Maximum', ...props });
+    }
+    /**
+     * Metric for ECPUs consumed
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Average over 5 minutes
+     */
+    metricProcessingUnitsConsumed(props) {
+        return this.metric('ElastiCacheProcessingUnits', props);
+    }
+    /**
+     * Metric for network bytes in
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Sum over 5 minutes
+     */
+    metricNetworkBytesIn(props) {
+        return this.metric('NetworkBytesIn', { statistic: 'Sum', ...props });
+    }
+    /**
+     * Metric for network bytes out
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Sum over 5 minutes
+     */
+    metricNetworkBytesOut(props) {
+        return this.metric('NetworkBytesOut', { statistic: 'Sum', ...props });
+    }
+    /**
+     * Metric for active connections
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Maximum over 5 minutes
+     */
+    metricActiveConnections(props) {
+        return this.metric('CurrConnections', { statistic: 'Maximum', ...props });
+    }
+    /**
+     * Metric for write request latency
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Average over 5 minutes
+     */
+    metricWriteRequestLatency(props) {
+        return this.metric('SuccessfulWriteRequestLatency', props);
+    }
+    /**
+     * Metric for read request latency
+     *
+     * @param props Additional properties which will be merged with the default metric
+     * @default Average over 5 minutes
+     */
+    metricReadRequestLatency(props) {
+        return this.metric('SuccessfulReadRequestLatency', props);
+    }
+}
+exports.ServerlessCacheBase = ServerlessCacheBase;
+_a = JSII_RTTI_SYMBOL_1;
+ServerlessCacheBase[_a] = { fqn: "@aws-cdk/aws-elasticache-alpha.ServerlessCacheBase", version: "2.218.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serverless-cache-base.js","sourceRoot":"","sources":["serverless-cache-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { IUserGroup } from './user-group';\nimport * as cloudwatch from 'aws-cdk-lib/aws-cloudwatch';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport { IResource, Resource, Duration } from 'aws-cdk-lib/core';\n\n/**\n * Supported cache engines together with available versions.\n */\nexport enum CacheEngine {\n  /**\n   * Valkey engine, latest major version available, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  VALKEY_LATEST = 'valkey',\n  /**\n   * Valkey engine, major version 7, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  VALKEY_7 = 'valkey_7',\n  /**\n   * Valkey engine, major version 8, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  VALKEY_8 = 'valkey_8',\n  /**\n   * Redis engine, latest major version available, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  REDIS_LATEST = 'redis',\n  /**\n   * Redis engine, major version 7, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  REDIS_7 = 'redis_7',\n  /**\n   * Memcached engine, latest major version available, minor version is selected automatically\n   * For more information about the features related to this version check: https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html\n   */\n  MEMCACHED_LATEST = 'memcached',\n}\n\n/**\n * Represents a Serverless ElastiCache cache\n */\nexport interface IServerlessCache extends IResource, ec2.IConnectable {\n  /**\n   * The cache engine used by this cache\n   */\n  readonly engine?: CacheEngine;\n  /**\n   * The name of the serverless cache\n   *\n   * @attribute\n   */\n  readonly serverlessCacheName: string;\n  /**\n   * The ARNs of backups restored in the cache\n   */\n  readonly backupArnsToRestore?: string[];\n  /**\n   * The KMS key used for encryption\n   */\n  readonly kmsKey?: kms.IKey;\n  /**\n   * The VPC this cache is deployed in\n   */\n  readonly vpc?: ec2.IVpc;\n  /**\n   * The subnets this cache is deployed in\n   */\n  readonly subnets?: ec2.ISubnet[];\n  /**\n   * The security groups associated with this cache\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n  /**\n   * The user group associated with this cache\n   */\n  readonly userGroup?: IUserGroup;\n  /**\n   * The ARN of the serverless cache\n   *\n   * @attribute\n   */\n  readonly serverlessCacheArn: string;\n\n  /**\n   * Grant connect permissions to the cache\n   */\n  grantConnect(grantee: iam.IGrantable): iam.Grant;\n  /**\n   * Grant the given identity custom permissions\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Return the given named metric for this cache\n   */\n  metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for cache hit count\n   */\n  metricCacheHitCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for cache miss count\n   */\n  metricCacheMissCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for cache hit rate\n   */\n  metricCacheHitRate(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for data stored in the cache\n   */\n  metricDataStored(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for ECPUs consumed\n   */\n  metricProcessingUnitsConsumed(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for network bytes in\n   */\n  metricNetworkBytesIn(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for network bytes out\n   */\n  metricNetworkBytesOut(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for active connections\n   */\n  metricActiveConnections(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for write request latency\n   */\n  metricWriteRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n  /**\n   * Metric for read request latency\n   */\n  metricReadRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * Base class for ServerlessCache constructs\n */\nexport abstract class ServerlessCacheBase extends Resource implements IServerlessCache {\n  public abstract readonly engine?: CacheEngine;\n  public abstract readonly serverlessCacheName: string;\n  public abstract readonly backupArnsToRestore?: string[];\n  public abstract readonly kmsKey?: kms.IKey;\n  public abstract readonly vpc?: ec2.IVpc;\n  public abstract readonly subnets?: ec2.ISubnet[];\n  public abstract readonly securityGroups?: ec2.ISecurityGroup[];\n  public abstract readonly userGroup?: IUserGroup;\n\n  public abstract readonly serverlessCacheArn: string;\n\n  /**\n   * Access to network connections.\n   */\n  public abstract readonly connections: ec2.Connections;\n\n  /**\n   * Grant connect permissions to the cache\n   *\n   * @param grantee The principal to grant permissions to\n   */\n  public grantConnect(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'elasticache:Connect', 'elasticache:DescribeServerlessCaches');\n  }\n  /**\n   * Grant the given identity custom permissions\n   *\n   * @param grantee The principal to grant permissions to\n   * @param actions The actions to grant\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.serverlessCacheArn],\n    });\n  }\n\n  /**\n   * Return the given named metric for this cache\n   *\n   * @param metricName The name of the metric\n   * @param props Additional properties which will be merged with the default metric\n   * @default Average over 5 minutes\n   */\n  public metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: 'AWS/ElastiCache',\n      metricName,\n      dimensionsMap: {\n        ServerlessCacheName: this.serverlessCacheName,\n      },\n      period: Duration.minutes(5),\n      statistic: 'Average',\n      ...props,\n    }).attachTo(this);\n  }\n  /**\n   * Metric for cache hit count\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Sum over 5 minutes\n   */\n  public metricCacheHitCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('CacheHits', { statistic: 'Sum', ...props });\n  }\n  /**\n   * Metric for cache miss count\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Sum over 5 minutes\n   */\n  public metricCacheMissCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('CacheMisses', { statistic: 'Sum', ...props });\n  }\n  /**\n   * Metric for cache hit rate\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Average over 5 minutes\n   */\n  public metricCacheHitRate(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('CacheHitRate', props);\n  }\n  /**\n   * Metric for data stored in the cache\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Maximum over 5 minutes\n   */\n  public metricDataStored(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('BytesUsedForCache', { statistic: 'Maximum', ...props });\n  }\n  /**\n   * Metric for ECPUs consumed\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Average over 5 minutes\n   */\n  public metricProcessingUnitsConsumed(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('ElastiCacheProcessingUnits', props);\n  }\n  /**\n   * Metric for network bytes in\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Sum over 5 minutes\n   */\n  public metricNetworkBytesIn(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('NetworkBytesIn', { statistic: 'Sum', ...props });\n  }\n  /**\n   * Metric for network bytes out\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Sum over 5 minutes\n   */\n  public metricNetworkBytesOut(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('NetworkBytesOut', { statistic: 'Sum', ...props });\n  }\n  /**\n   * Metric for active connections\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Maximum over 5 minutes\n   */\n  public metricActiveConnections(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('CurrConnections', { statistic: 'Maximum', ...props });\n  }\n  /**\n   * Metric for write request latency\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Average over 5 minutes\n   */\n  public metricWriteRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('SuccessfulWriteRequestLatency', props);\n  }\n  /**\n   * Metric for read request latency\n   *\n   * @param props Additional properties which will be merged with the default metric\n   * @default Average over 5 minutes\n   */\n  public metricReadRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('SuccessfulReadRequestLatency', props);\n  }\n}\n"]}

package/lib/serverless-cache.d.ts

@@ -0,0 +1,341 @@
+import { Construct } from 'constructs';
+import { IServerlessCache, ServerlessCacheBase, CacheEngine } from './serverless-cache-base';
+import { IUserGroup } from './user-group';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as events from 'aws-cdk-lib/aws-events';
+import * as kms from 'aws-cdk-lib/aws-kms';
+import { Size } from 'aws-cdk-lib/core';
+/**
+ * Usage limits configuration for ServerlessCache
+ */
+export interface CacheUsageLimitsProperty {
+    /**
+     * Minimum data storage size (1 GB)
+     *
+     * @default - No minimum limit
+     */
+    readonly dataStorageMinimumSize?: Size;
+    /**
+     * Maximum data storage size (5000 GB)
+     *
+     * @default - No maximum limit
+     */
+    readonly dataStorageMaximumSize?: Size;
+    /**
+     * Minimum request rate limit (1000 ECPUs per second)
+     *
+     * @default - No minimum limit
+     */
+    readonly requestRateLimitMinimum?: number;
+    /**
+     * Maximum request rate limit (15000000 ECPUs per second)
+     *
+     * @default - No maximum limit
+     */
+    readonly requestRateLimitMaximum?: number;
+}
+/**
+ * Backup configuration for ServerlessCache
+ */
+export interface BackupSettings {
+    /**
+     * Automated daily backup UTC time
+     *
+     * @default - No automated backups
+     */
+    readonly backupTime?: events.Schedule;
+    /**
+     * Number of days to retain backups (1-35)
+     *
+     * @default - Backups are not retained
+     */
+    readonly backupRetentionLimit?: number;
+    /**
+     * Name for the final backup taken before deletion
+     *
+     * @default - No final backup
+     */
+    readonly backupNameBeforeDeletion?: string;
+    /**
+     * ARNs of backups from which to restore data into the new cache
+     *
+     * @default - Create a new cache with no existing data
+     */
+    readonly backupArnsToRestore?: string[];
+}
+/**
+ * Properties for defining a ServerlessCache
+ */
+export interface ServerlessCacheProps {
+    /**
+     * The cache engine combined with the version
+     * Enum options: VALKEY_DEFAULT, VALKEY_7, VALKEY_8, REDIS_DEFAULT, MEMCACHED_DEFAULT
+     * The default options bring the latest versions available.
+     *
+     * @default when not provided, the default engine would be Valkey, latest version available (VALKEY_DEFAULT)
+     */
+    readonly engine?: CacheEngine;
+    /**
+     * Name for the serverless cache
+     *
+     * @default automatically generated name by Resource
+     */
+    readonly serverlessCacheName?: string;
+    /**
+     * A description for the cache
+     *
+     * @default - No description
+     */
+    readonly description?: string;
+    /**
+     * Usage limits for the cache
+     *
+     * @default - No usage limits
+     */
+    readonly cacheUsageLimits?: CacheUsageLimitsProperty;
+    /**
+     * Backup configuration
+     *
+     * @default - No backups configured
+     */
+    readonly backup?: BackupSettings;
+    /**
+     * KMS key for encryption
+     *
+     * @default - Service managed encryption (AWS owned KMS key)
+     */
+    readonly kmsKey?: kms.IKey;
+    /**
+     * The VPC to place the cache in
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * Which subnets to place the cache in
+     *
+     * @default - Private subnets with egress
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * Security groups for the cache
+     *
+     * @default - A new security group is created
+     */
+    readonly securityGroups?: ec2.ISecurityGroup[];
+    /**
+     * User group for access control
+     *
+     * @default - No user group
+     */
+    readonly userGroup?: IUserGroup;
+}
+/**
+ * Attributes that can be specified when importing a ServerlessCache
+ */
+export interface ServerlessCacheAttributes {
+    /**
+     * The cache engine used by this cache
+     *
+     * @default - engine type is unknown
+     */
+    readonly engine?: CacheEngine;
+    /**
+     * The name of the serverless cache
+     *
+     * One of `serverlessCacheName` or `serverlessCacheArn` is required.
+     *
+     * @default - derived from serverlessCacheArn
+     */
+    readonly serverlessCacheName?: string;
+    /**
+     * The ARN of the serverless cache
+     *
+     * One of `serverlessCacheName` or `serverlessCacheArn` is required.
+     *
+     * @default - derived from serverlessCacheName
+     */
+    readonly serverlessCacheArn?: string;
+    /**
+     * The ARNs of backups restored in the cache
+     *
+     * @default - backups are unknown
+     */
+    readonly backupArnsToRestore?: string[];
+    /**
+     * The KMS key used for encryption
+     *
+     * @default - encryption key is unknown
+     */
+    readonly kmsKey?: kms.IKey;
+    /**
+     * The VPC this cache is deployed in
+     *
+     * @default - VPC is unknown
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * The subnets this cache is deployed in
+     *
+     * @default - subnets are unknown
+     */
+    readonly subnets?: ec2.ISubnet[];
+    /**
+     * The security groups associated with this cache
+     *
+     * @default - security groups are unknown
+     */
+    readonly securityGroups?: ec2.ISecurityGroup[];
+    /**
+     * The user group associated with this cache
+     *
+     * @default - user group is unknown
+     */
+    readonly userGroup?: IUserGroup;
+}
+/**
+ * A serverless ElastiCache cache
+ *
+ * @resource AWS::ElastiCache::ServerlessCache
+ */
+export declare class ServerlessCache extends ServerlessCacheBase {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Return whether the given object is a `ServerlessCache`
+     */
+    static isServerlessCache(x: any): x is ServerlessCache;
+    /**
+     * 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: Construct, id: string, serverlessCacheName: string): IServerlessCache;
+    /**
+     * 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: Construct, id: string, serverlessCacheArn: string): IServerlessCache;
+    /**
+     * 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: Construct, id: string, attrs: ServerlessCacheAttributes): IServerlessCache;
+    readonly engine?: CacheEngine;
+    readonly serverlessCacheName: string;
+    readonly backupArnsToRestore?: string[];
+    readonly kmsKey?: kms.IKey;
+    readonly vpc?: ec2.IVpc;
+    readonly subnets?: ec2.ISubnet[];
+    readonly securityGroups?: ec2.ISecurityGroup[];
+    readonly userGroup?: IUserGroup;
+    /**
+     * The ARN of the serverless cache
+     *
+     * @attribute
+     */
+    readonly serverlessCacheArn: string;
+    /**
+     * The endpoint address of the serverless cache
+     *
+     * @attribute
+     */
+    readonly serverlessCacheEndpointAddress: string;
+    /**
+     * The endpoint port of the serverless cache
+     *
+     * @attribute
+     */
+    readonly serverlessCacheEndpointPort: string;
+    /**
+     * The reader endpoint address of the serverless cache
+     *
+     * @attribute
+     */
+    readonly serverlessCacheReaderEndpointAddress: string;
+    /**
+     * The reader endpoint port of the serverless cache
+     *
+     * @attribute
+     */
+    readonly serverlessCacheReaderEndpointPort: string;
+    /**
+     * The current status of the serverless cache
+     * Can be 'CREATING', 'AVAILABLE', 'DELETING', 'CREATE-FAILED', 'MODIFYING'
+     *
+     * @attribute
+     */
+    readonly serverlessCacheStatus: string;
+    /**
+     * Access to network connections
+     */
+    readonly connections: ec2.Connections;
+    constructor(scope: Construct, id: string, props: ServerlessCacheProps);
+    /**
+     * Validate description meets AWS requirements
+     *
+     * @param description The description to validate
+     */
+    private validateDescription;
+    /**
+     * Validate data storage size limits
+     *
+     * @param limits The usage limits containing data storage settings
+     */
+    private validateDataStorageLimits;
+    /**
+     * Validate request rate limits
+     *
+     * @param limits The usage limits containing request rate settings
+     */
+    private validateRequestRateLimits;
+    /**
+     * Validate backup settings meet AWS requirements
+     *
+     * @param backup The backup settings to validate
+     */
+    private validateBackupSettings;
+    /**
+     * Validate user group compatibility with cache engine
+     *
+     * @param engine The cache engine
+     * @param userGroup The user group to validate
+     */
+    private validateUserGroupCompatibility;
+    /**
+     * Render cache usage limits for CloudFormation
+     *
+     * @param limits The usage limits to render
+     * @returns CloudFormation-compatible usage limits object or undefined
+     */
+    private renderCacheUsageLimits;
+    /**
+     * Configure subnets for the cache
+     *
+     * @param props The ServerlessCache properties
+     * @returns Object containing subnet IDs and subnet objects
+     */
+    private configureSubnets;
+    /**
+     * Configure security groups for the cache
+     *
+     * @param props The ServerlessCache properties
+     * @returns Object containing security group IDs and security group objects
+     */
+    private configureSecurityGroups;
+    /**
+     * Format schedule to HH:MM format for daily backups
+     *
+     * @param schedule The schedule to format
+     * @returns Time string in HH:MM format
+     */
+    private formatBackupTime;
+}