@aws-sdk/client-elasticache 3.1075.0 → 3.1077.0

package/dist-cjs/index.js

@@ -1,21 +1,58 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultElastiCacheHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { AddTagsToResource$, AuthorizeCacheSecurityGroupIngress$, BatchApplyUpdateAction$, BatchStopUpdateAction$, CompleteMigration$, CopyServerlessCacheSnapshot$, CopySnapshot$, CreateCacheCluster$, CreateCacheParameterGroup$, CreateCacheSecurityGroup$, CreateCacheSubnetGroup$, CreateGlobalReplicationGroup$, CreateReplicationGroup$, CreateServerlessCache$, CreateServerlessCacheSnapshot$, CreateSnapshot$, CreateUser$, CreateUserGroup$, DecreaseNodeGroupsInGlobalReplicationGroup$, DecreaseReplicaCount$, DeleteCacheCluster$, DeleteCacheParameterGroup$, DeleteCacheSecurityGroup$, DeleteCacheSubnetGroup$, DeleteGlobalReplicationGroup$, DeleteReplicationGroup$, DeleteServerlessCache$, DeleteServerlessCacheSnapshot$, DeleteSnapshot$, DeleteUser$, DeleteUserGroup$, DescribeCacheClusters$, DescribeCacheEngineVersions$, DescribeCacheParameterGroups$, DescribeCacheParameters$, DescribeCacheSecurityGroups$, DescribeCacheSubnetGroups$, DescribeEngineDefaultParameters$, DescribeEvents$, DescribeGlobalReplicationGroups$, DescribeReplicationGroups$, DescribeReservedCacheNodes$, DescribeReservedCacheNodesOfferings$, DescribeServerlessCaches$, DescribeServerlessCacheSnapshots$, DescribeServiceUpdates$, DescribeSnapshots$, DescribeUpdateActions$, DescribeUserGroups$, DescribeUsers$, DisassociateGlobalReplicationGroup$, ExportServerlessCacheSnapshot$, FailoverGlobalReplicationGroup$, IncreaseNodeGroupsInGlobalReplicationGroup$, IncreaseReplicaCount$, ListAllowedNodeTypeModifications$, ListTagsForResource$, ModifyCacheCluster$, ModifyCacheParameterGroup$, ModifyCacheSubnetGroup$, ModifyGlobalReplicationGroup$, ModifyReplicationGroup$, ModifyReplicationGroupShardConfiguration$, ModifyServerlessCache$, ModifyUser$, ModifyUserGroup$, PurchaseReservedCacheNodesOffering$, RebalanceSlotsInGlobalReplicationGroup$, RebootCacheCluster$, RemoveTagsFromResource$, ResetCacheParameterGroup$, RevokeCacheSecurityGroupIngress$, StartMigration$, TestFailover$, TestMigration$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { ElastiCacheServiceException } = require("./models/ElastiCacheServiceException");
-exports.ElastiCacheServiceException = ElastiCacheServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsQueryProtocol } = require("@aws-sdk/core/protocols");
+const { Sha256 } = require("@smithy/core/checksum");
+
+const defaultElastiCacheHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "elasticache",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultElastiCacheHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +68,3757 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1076.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
+        ["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://elasticache-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://elasticache.{Region}.amazonaws.com", i],
+        ["https://elasticache-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://elasticache.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://elasticache.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 13, 3,
+    1, 4, r + 12,
+    2, 5, r + 12,
+    3, 8, 6,
+    4, 7, r + 11,
+    5, r + 9, r + 10,
+    4, 11, 9,
+    6, 10, r + 8,
+    7, r + 6, r + 7,
+    5, 12, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 14,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class ElastiCacheServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, ElastiCacheServiceException.prototype);
+    }
+}
+
+class CacheClusterNotFoundFault extends ElastiCacheServiceException {
+    name = "CacheClusterNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheClusterNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheClusterNotFoundFault.prototype);
+    }
+}
+class CacheParameterGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "CacheParameterGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheParameterGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheParameterGroupNotFoundFault.prototype);
+    }
+}
+class CacheSecurityGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "CacheSecurityGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSecurityGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSecurityGroupNotFoundFault.prototype);
+    }
+}
+class CacheSubnetGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "CacheSubnetGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSubnetGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSubnetGroupNotFoundFault.prototype);
+    }
+}
+class InvalidARNFault extends ElastiCacheServiceException {
+    name = "InvalidARNFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidARNFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidARNFault.prototype);
+    }
+}
+class InvalidReplicationGroupStateFault extends ElastiCacheServiceException {
+    name = "InvalidReplicationGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReplicationGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReplicationGroupStateFault.prototype);
+    }
+}
+class InvalidServerlessCacheSnapshotStateFault extends ElastiCacheServiceException {
+    name = "InvalidServerlessCacheSnapshotStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidServerlessCacheSnapshotStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidServerlessCacheSnapshotStateFault.prototype);
+    }
+}
+class InvalidServerlessCacheStateFault extends ElastiCacheServiceException {
+    name = "InvalidServerlessCacheStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidServerlessCacheStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidServerlessCacheStateFault.prototype);
+    }
+}
+class ReplicationGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "ReplicationGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplicationGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplicationGroupNotFoundFault.prototype);
+    }
+}
+class ReservedCacheNodeNotFoundFault extends ElastiCacheServiceException {
+    name = "ReservedCacheNodeNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReservedCacheNodeNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReservedCacheNodeNotFoundFault.prototype);
+    }
+}
+class ServerlessCacheNotFoundFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheNotFoundFault.prototype);
+    }
+}
+class ServerlessCacheSnapshotNotFoundFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheSnapshotNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheSnapshotNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheSnapshotNotFoundFault.prototype);
+    }
+}
+class SnapshotNotFoundFault extends ElastiCacheServiceException {
+    name = "SnapshotNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SnapshotNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SnapshotNotFoundFault.prototype);
+    }
+}
+class TagQuotaPerResourceExceeded extends ElastiCacheServiceException {
+    name = "TagQuotaPerResourceExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagQuotaPerResourceExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagQuotaPerResourceExceeded.prototype);
+    }
+}
+class UserGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "UserGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserGroupNotFoundFault.prototype);
+    }
+}
+class UserNotFoundFault extends ElastiCacheServiceException {
+    name = "UserNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserNotFoundFault.prototype);
+    }
+}
+class AuthorizationAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "AuthorizationAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AuthorizationAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AuthorizationAlreadyExistsFault.prototype);
+    }
+}
+class InvalidCacheSecurityGroupStateFault extends ElastiCacheServiceException {
+    name = "InvalidCacheSecurityGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCacheSecurityGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCacheSecurityGroupStateFault.prototype);
+    }
+}
+class InvalidParameterCombinationException extends ElastiCacheServiceException {
+    name = "InvalidParameterCombinationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterCombinationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterCombinationException.prototype);
+    }
+}
+class InvalidParameterValueException extends ElastiCacheServiceException {
+    name = "InvalidParameterValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
+    }
+}
+class ServiceUpdateNotFoundFault extends ElastiCacheServiceException {
+    name = "ServiceUpdateNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceUpdateNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceUpdateNotFoundFault.prototype);
+    }
+}
+class ReplicationGroupNotUnderMigrationFault extends ElastiCacheServiceException {
+    name = "ReplicationGroupNotUnderMigrationFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplicationGroupNotUnderMigrationFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplicationGroupNotUnderMigrationFault.prototype);
+    }
+}
+class ServerlessCacheSnapshotAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheSnapshotAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheSnapshotAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheSnapshotAlreadyExistsFault.prototype);
+    }
+}
+class ServerlessCacheSnapshotQuotaExceededFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheSnapshotQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheSnapshotQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheSnapshotQuotaExceededFault.prototype);
+    }
+}
+class ServiceLinkedRoleNotFoundFault extends ElastiCacheServiceException {
+    name = "ServiceLinkedRoleNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceLinkedRoleNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceLinkedRoleNotFoundFault.prototype);
+    }
+}
+class InvalidSnapshotStateFault extends ElastiCacheServiceException {
+    name = "InvalidSnapshotStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSnapshotStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSnapshotStateFault.prototype);
+    }
+}
+class SnapshotAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "SnapshotAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SnapshotAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SnapshotAlreadyExistsFault.prototype);
+    }
+}
+class SnapshotQuotaExceededFault extends ElastiCacheServiceException {
+    name = "SnapshotQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SnapshotQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SnapshotQuotaExceededFault.prototype);
+    }
+}
+class CacheClusterAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "CacheClusterAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheClusterAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheClusterAlreadyExistsFault.prototype);
+    }
+}
+class ClusterQuotaForCustomerExceededFault extends ElastiCacheServiceException {
+    name = "ClusterQuotaForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ClusterQuotaForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClusterQuotaForCustomerExceededFault.prototype);
+    }
+}
+class InsufficientCacheClusterCapacityFault extends ElastiCacheServiceException {
+    name = "InsufficientCacheClusterCapacityFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InsufficientCacheClusterCapacityFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InsufficientCacheClusterCapacityFault.prototype);
+    }
+}
+class InvalidVPCNetworkStateFault extends ElastiCacheServiceException {
+    name = "InvalidVPCNetworkStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidVPCNetworkStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidVPCNetworkStateFault.prototype);
+    }
+}
+class NodeQuotaForClusterExceededFault extends ElastiCacheServiceException {
+    name = "NodeQuotaForClusterExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeQuotaForClusterExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeQuotaForClusterExceededFault.prototype);
+    }
+}
+class NodeQuotaForCustomerExceededFault extends ElastiCacheServiceException {
+    name = "NodeQuotaForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeQuotaForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeQuotaForCustomerExceededFault.prototype);
+    }
+}
+class CacheParameterGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "CacheParameterGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheParameterGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheParameterGroupAlreadyExistsFault.prototype);
+    }
+}
+class CacheParameterGroupQuotaExceededFault extends ElastiCacheServiceException {
+    name = "CacheParameterGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheParameterGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheParameterGroupQuotaExceededFault.prototype);
+    }
+}
+class InvalidCacheParameterGroupStateFault extends ElastiCacheServiceException {
+    name = "InvalidCacheParameterGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCacheParameterGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCacheParameterGroupStateFault.prototype);
+    }
+}
+class CacheSecurityGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "CacheSecurityGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSecurityGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSecurityGroupAlreadyExistsFault.prototype);
+    }
+}
+class CacheSecurityGroupQuotaExceededFault extends ElastiCacheServiceException {
+    name = "CacheSecurityGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSecurityGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSecurityGroupQuotaExceededFault.prototype);
+    }
+}
+class CacheSubnetGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "CacheSubnetGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSubnetGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSubnetGroupAlreadyExistsFault.prototype);
+    }
+}
+class CacheSubnetGroupQuotaExceededFault extends ElastiCacheServiceException {
+    name = "CacheSubnetGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSubnetGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSubnetGroupQuotaExceededFault.prototype);
+    }
+}
+class CacheSubnetQuotaExceededFault extends ElastiCacheServiceException {
+    name = "CacheSubnetQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSubnetQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSubnetQuotaExceededFault.prototype);
+    }
+}
+class InvalidSubnet extends ElastiCacheServiceException {
+    name = "InvalidSubnet";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSubnet",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSubnet.prototype);
+    }
+}
+class SubnetNotAllowedFault extends ElastiCacheServiceException {
+    name = "SubnetNotAllowedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetNotAllowedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetNotAllowedFault.prototype);
+    }
+}
+class GlobalReplicationGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "GlobalReplicationGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "GlobalReplicationGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, GlobalReplicationGroupAlreadyExistsFault.prototype);
+    }
+}
+class GlobalReplicationGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "GlobalReplicationGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "GlobalReplicationGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, GlobalReplicationGroupNotFoundFault.prototype);
+    }
+}
+class InvalidCacheClusterStateFault extends ElastiCacheServiceException {
+    name = "InvalidCacheClusterStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCacheClusterStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCacheClusterStateFault.prototype);
+    }
+}
+class InvalidGlobalReplicationGroupStateFault extends ElastiCacheServiceException {
+    name = "InvalidGlobalReplicationGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidGlobalReplicationGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidGlobalReplicationGroupStateFault.prototype);
+    }
+}
+class InvalidUserGroupStateFault extends ElastiCacheServiceException {
+    name = "InvalidUserGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidUserGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidUserGroupStateFault.prototype);
+    }
+}
+class NodeGroupsPerReplicationGroupQuotaExceededFault extends ElastiCacheServiceException {
+    name = "NodeGroupsPerReplicationGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeGroupsPerReplicationGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeGroupsPerReplicationGroupQuotaExceededFault.prototype);
+    }
+}
+class ReplicationGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "ReplicationGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplicationGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplicationGroupAlreadyExistsFault.prototype);
+    }
+}
+class InvalidCredentialsException extends ElastiCacheServiceException {
+    name = "InvalidCredentialsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCredentialsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCredentialsException.prototype);
+    }
+}
+class ServerlessCacheAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheAlreadyExistsFault.prototype);
+    }
+}
+class ServerlessCacheQuotaForCustomerExceededFault extends ElastiCacheServiceException {
+    name = "ServerlessCacheQuotaForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServerlessCacheQuotaForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerlessCacheQuotaForCustomerExceededFault.prototype);
+    }
+}
+class SnapshotFeatureNotSupportedFault extends ElastiCacheServiceException {
+    name = "SnapshotFeatureNotSupportedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SnapshotFeatureNotSupportedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SnapshotFeatureNotSupportedFault.prototype);
+    }
+}
+class DuplicateUserNameFault extends ElastiCacheServiceException {
+    name = "DuplicateUserNameFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DuplicateUserNameFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DuplicateUserNameFault.prototype);
+    }
+}
+class UserAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "UserAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserAlreadyExistsFault.prototype);
+    }
+}
+class UserQuotaExceededFault extends ElastiCacheServiceException {
+    name = "UserQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserQuotaExceededFault.prototype);
+    }
+}
+class DefaultUserRequired extends ElastiCacheServiceException {
+    name = "DefaultUserRequired";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DefaultUserRequired",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DefaultUserRequired.prototype);
+    }
+}
+class UserGroupAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "UserGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserGroupAlreadyExistsFault.prototype);
+    }
+}
+class UserGroupQuotaExceededFault extends ElastiCacheServiceException {
+    name = "UserGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UserGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UserGroupQuotaExceededFault.prototype);
+    }
+}
+class NoOperationFault extends ElastiCacheServiceException {
+    name = "NoOperationFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NoOperationFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NoOperationFault.prototype);
+    }
+}
+class CacheSubnetGroupInUse extends ElastiCacheServiceException {
+    name = "CacheSubnetGroupInUse";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CacheSubnetGroupInUse",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CacheSubnetGroupInUse.prototype);
+    }
+}
+class DefaultUserAssociatedToUserGroupFault extends ElastiCacheServiceException {
+    name = "DefaultUserAssociatedToUserGroupFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DefaultUserAssociatedToUserGroupFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DefaultUserAssociatedToUserGroupFault.prototype);
+    }
+}
+class InvalidUserStateFault extends ElastiCacheServiceException {
+    name = "InvalidUserStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidUserStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidUserStateFault.prototype);
+    }
+}
+class ReservedCacheNodesOfferingNotFoundFault extends ElastiCacheServiceException {
+    name = "ReservedCacheNodesOfferingNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReservedCacheNodesOfferingNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReservedCacheNodesOfferingNotFoundFault.prototype);
+    }
+}
+class InvalidKMSKeyFault extends ElastiCacheServiceException {
+    name = "InvalidKMSKeyFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidKMSKeyFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidKMSKeyFault.prototype);
+    }
+}
+class SubnetInUse extends ElastiCacheServiceException {
+    name = "SubnetInUse";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetInUse",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetInUse.prototype);
+    }
+}
+class ReservedCacheNodeAlreadyExistsFault extends ElastiCacheServiceException {
+    name = "ReservedCacheNodeAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReservedCacheNodeAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReservedCacheNodeAlreadyExistsFault.prototype);
+    }
+}
+class ReservedCacheNodeQuotaExceededFault extends ElastiCacheServiceException {
+    name = "ReservedCacheNodeQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReservedCacheNodeQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReservedCacheNodeQuotaExceededFault.prototype);
+    }
+}
+class TagNotFoundFault extends ElastiCacheServiceException {
+    name = "TagNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagNotFoundFault.prototype);
+    }
+}
+class AuthorizationNotFoundFault extends ElastiCacheServiceException {
+    name = "AuthorizationNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AuthorizationNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AuthorizationNotFoundFault.prototype);
+    }
+}
+class ReplicationGroupAlreadyUnderMigrationFault extends ElastiCacheServiceException {
+    name = "ReplicationGroupAlreadyUnderMigrationFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplicationGroupAlreadyUnderMigrationFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplicationGroupAlreadyUnderMigrationFault.prototype);
+    }
+}
+class APICallRateForCustomerExceededFault extends ElastiCacheServiceException {
+    name = "APICallRateForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "APICallRateForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, APICallRateForCustomerExceededFault.prototype);
+    }
+}
+class NodeGroupNotFoundFault extends ElastiCacheServiceException {
+    name = "NodeGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeGroupNotFoundFault.prototype);
+    }
+}
+class TestFailoverNotAvailableFault extends ElastiCacheServiceException {
+    name = "TestFailoverNotAvailableFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TestFailoverNotAvailableFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TestFailoverNotAvailableFault.prototype);
+    }
+}
+
+const _A = "Authentication";
+const _AAEF = "AuthorizationAlreadyExistsFault";
+const _AAS = "AppendAccessString";
+const _ACSGI = "AuthorizeCacheSecurityGroupIngress";
+const _ACSGIM = "AuthorizeCacheSecurityGroupIngressMessage";
+const _ACSGIR = "AuthorizeCacheSecurityGroupIngressResult";
+const _AF = "AutomaticFailover";
+const _AFE = "AutomaticFailoverEnabled";
+const _AFS = "AutomaticFailoverStatus";
+const _AI = "ApplyImmediately";
+const _AM = "AuthenticationMode";
+const _AMVU = "AutoMinorVersionUpgrade";
+const _ANFF = "AuthorizationNotFoundFault";
+const _ANTMM = "AllowedNodeTypeModificationsMessage";
+const _APICRFCEF = "APICallRateForCustomerExceededFault";
+const _AREE = "AtRestEncryptionEnabled";
+const _ARN = "ARN";
+const _AS = "AccessString";
+const _AT = "AuthToken";
+const _ATE = "AuthTokenEnabled";
+const _ATLMD = "AuthTokenLastModifiedDate";
+const _ATS = "AuthTokenStatus";
+const _ATTR = "AddTagsToResource";
+const _ATTRM = "AddTagsToResourceMessage";
+const _ATUS = "AuthTokenUpdateStrategy";
+const _AUARABD = "AutoUpdateAfterRecommendedApplyByDate";
+const _AV = "AllowedValues";
+const _AZ = "AvailabilityZone";
+const _AZL = "AvailabilityZonesList";
+const _AZM = "AZMode";
+const _Ad = "Address";
+const _BAUA = "BatchApplyUpdateAction";
+const _BAUAM = "BatchApplyUpdateActionMessage";
+const _BSUA = "BatchStopUpdateAction";
+const _BSUAM = "BatchStopUpdateActionMessage";
+const _BUFC = "BytesUsedForCache";
+const _CAZ = "CustomerAvailabilityZone";
+const _CC = "CacheCluster";
+const _CCAEF = "CacheClusterAlreadyExistsFault";
+const _CCC = "CreateCacheCluster";
+const _CCCM = "CreateCacheClusterMessage";
+const _CCCR = "CreateCacheClusterResult";
+const _CCCT = "CacheClusterCreateTime";
+const _CCI = "CacheClusterIds";
+const _CCIa = "CacheClusterId";
+const _CCL = "CacheClusterList";
+const _CCM = "CacheClusterMessage";
+const _CCNFF = "CacheClusterNotFoundFault";
+const _CCPG = "CreateCacheParameterGroup";
+const _CCPGM = "CreateCacheParameterGroupMessage";
+const _CCPGR = "CreateCacheParameterGroupResult";
+const _CCS = "CacheClusterStatus";
+const _CCSG = "CreateCacheSecurityGroup";
+const _CCSGM = "CreateCacheSecurityGroupMessage";
+const _CCSGMr = "CreateCacheSubnetGroupMessage";
+const _CCSGR = "CreateCacheSecurityGroupResult";
+const _CCSGRr = "CreateCacheSubnetGroupResult";
+const _CCSGr = "CreateCacheSubnetGroup";
+const _CCa = "CacheClusters";
+const _CDLP = "ClientDownloadLandingPage";
+const _CE = "ConfigurationEndpoint";
+const _CED = "CacheEngineDescription";
+const _CEV = "CacheEngineVersion";
+const _CEVD = "CacheEngineVersionDescription";
+const _CEVL = "CacheEngineVersionList";
+const _CEVM = "CacheEngineVersionMessage";
+const _CEVa = "CacheEngineVersions";
+const _CEl = "ClusterEnabled";
+const _CGRG = "CreateGlobalReplicationGroup";
+const _CGRGM = "CreateGlobalReplicationGroupMessage";
+const _CGRGR = "CreateGlobalReplicationGroupResult";
+const _CI = "ClusterId";
+const _CIL = "ClusterIdList";
+const _CM = "ClusterMode";
+const _CMM = "CompleteMigrationMessage";
+const _CMR = "CompleteMigrationResponse";
+const _CMo = "CompleteMigration";
+const _CN = "CacheNodes";
+const _CNC = "CacheNodeCount";
+const _CNCT = "CacheNodeCreateTime";
+const _CNE = "CustomerNodeEndpoint";
+const _CNEL = "CustomerNodeEndpointList";
+const _CNI = "CacheNodeId";
+const _CNIL = "CacheNodeIdsList";
+const _CNITR = "CacheNodeIdsToReboot";
+const _CNITRa = "CacheNodeIdsToRemove";
+const _CNL = "CacheNodeList";
+const _CNS = "CacheNodeStatus";
+const _CNT = "CacheNodeType";
+const _CNTSP = "CacheNodeTypeSpecificParameter";
+const _CNTSPL = "CacheNodeTypeSpecificParametersList";
+const _CNTSPa = "CacheNodeTypeSpecificParameters";
+const _CNTSV = "CacheNodeTypeSpecificValues";
+const _CNTSVL = "CacheNodeTypeSpecificValueList";
+const _CNTSVa = "CacheNodeTypeSpecificValue";
+const _CNUS = "CacheNodeUpdateStatus";
+const _CNUSL = "CacheNodeUpdateStatusList";
+const _CNa = "CacheNode";
+const _COA = "CustomerOutpostArn";
+const _CPG = "CacheParameterGroup";
+const _CPGAEF = "CacheParameterGroupAlreadyExistsFault";
+const _CPGD = "CacheParameterGroupDetails";
+const _CPGF = "CacheParameterGroupFamily";
+const _CPGL = "CacheParameterGroupList";
+const _CPGM = "CacheParameterGroupsMessage";
+const _CPGN = "CacheParameterGroupName";
+const _CPGNFF = "CacheParameterGroupNotFoundFault";
+const _CPGNM = "CacheParameterGroupNameMessage";
+const _CPGQEF = "CacheParameterGroupQuotaExceededFault";
+const _CPGS = "CacheParameterGroupStatus";
+const _CPGa = "CacheParameterGroups";
+const _CQFCEF = "ClusterQuotaForCustomerExceededFault";
+const _CR = "CurrentRole";
+const _CRG = "CreateReplicationGroup";
+const _CRGM = "CreateReplicationGroupMessage";
+const _CRGR = "CreateReplicationGroupResult";
+const _CS = "ConfigureShard";
+const _CSC = "CreateServerlessCache";
+const _CSCR = "CreateServerlessCacheRequest";
+const _CSCRr = "CreateServerlessCacheResponse";
+const _CSCS = "CopyServerlessCacheSnapshot";
+const _CSCSR = "CopyServerlessCacheSnapshotRequest";
+const _CSCSRo = "CopyServerlessCacheSnapshotResponse";
+const _CSCSRr = "CreateServerlessCacheSnapshotRequest";
+const _CSCSRre = "CreateServerlessCacheSnapshotResponse";
+const _CSCSr = "CreateServerlessCacheSnapshot";
+const _CSG = "CacheSecurityGroup";
+const _CSGAEF = "CacheSecurityGroupAlreadyExistsFault";
+const _CSGAEFa = "CacheSubnetGroupAlreadyExistsFault";
+const _CSGD = "CacheSubnetGroupDescription";
+const _CSGIU = "CacheSubnetGroupInUse";
+const _CSGM = "CacheSecurityGroupMembership";
+const _CSGML = "CacheSecurityGroupMembershipList";
+const _CSGMa = "CacheSecurityGroupMessage";
+const _CSGMac = "CacheSubnetGroupMessage";
+const _CSGN = "CacheSecurityGroupName";
+const _CSGNFF = "CacheSecurityGroupNotFoundFault";
+const _CSGNFFa = "CacheSubnetGroupNotFoundFault";
+const _CSGNL = "CacheSecurityGroupNameList";
+const _CSGNa = "CacheSubnetGroupName";
+const _CSGNac = "CacheSecurityGroupNames";
+const _CSGQEF = "CacheSecurityGroupQuotaExceededFault";
+const _CSGQEFa = "CacheSubnetGroupQuotaExceededFault";
+const _CSGa = "CacheSecurityGroups";
+const _CSGac = "CacheSubnetGroup";
+const _CSGach = "CacheSubnetGroups";
+const _CSM = "CopySnapshotMessage";
+const _CSMr = "CreateSnapshotMessage";
+const _CSQEF = "CacheSubnetQuotaExceededFault";
+const _CSR = "CopySnapshotResult";
+const _CSRr = "CreateSnapshotResult";
+const _CSa = "CacheSize";
+const _CSo = "CopySnapshot";
+const _CSr = "CreateSnapshot";
+const _CT = "ChangeType";
+const _CTr = "CreateTime";
+const _CU = "CreateUser";
+const _CUG = "CreateUserGroup";
+const _CUGM = "CreateUserGroupMessage";
+const _CUL = "CacheUsageLimits";
+const _CUM = "CreateUserMessage";
+const _CWLD = "CloudWatchLogsDetails";
+const _CWLDD = "CloudWatchLogsDestinationDetails";
+const _D = "Description";
+const _DCC = "DeleteCacheCluster";
+const _DCCM = "DeleteCacheClusterMessage";
+const _DCCMe = "DescribeCacheClustersMessage";
+const _DCCR = "DeleteCacheClusterResult";
+const _DCCe = "DescribeCacheClusters";
+const _DCEV = "DescribeCacheEngineVersions";
+const _DCEVM = "DescribeCacheEngineVersionsMessage";
+const _DCP = "DescribeCacheParameters";
+const _DCPG = "DeleteCacheParameterGroup";
+const _DCPGM = "DeleteCacheParameterGroupMessage";
+const _DCPGMe = "DescribeCacheParameterGroupsMessage";
+const _DCPGe = "DescribeCacheParameterGroups";
+const _DCPM = "DescribeCacheParametersMessage";
+const _DCSG = "DeleteCacheSecurityGroup";
+const _DCSGM = "DeleteCacheSecurityGroupMessage";
+const _DCSGMe = "DeleteCacheSubnetGroupMessage";
+const _DCSGMes = "DescribeCacheSecurityGroupsMessage";
+const _DCSGMesc = "DescribeCacheSubnetGroupsMessage";
+const _DCSGe = "DeleteCacheSubnetGroup";
+const _DCSGes = "DescribeCacheSecurityGroups";
+const _DCSGesc = "DescribeCacheSubnetGroups";
+const _DD = "DestinationDetails";
+const _DE = "DescribeEvents";
+const _DEDP = "DescribeEngineDefaultParameters";
+const _DEDPM = "DescribeEngineDefaultParametersMessage";
+const _DEDPR = "DescribeEngineDefaultParametersResult";
+const _DEM = "DescribeEventsMessage";
+const _DGRG = "DeleteGlobalReplicationGroup";
+const _DGRGM = "DeleteGlobalReplicationGroupMessage";
+const _DGRGMe = "DescribeGlobalReplicationGroupsMessage";
+const _DGRGMi = "DisassociateGlobalReplicationGroupMessage";
+const _DGRGR = "DeleteGlobalReplicationGroupResult";
+const _DGRGRe = "DescribeGlobalReplicationGroupsResult";
+const _DGRGRi = "DisassociateGlobalReplicationGroupResult";
+const _DGRGe = "DescribeGlobalReplicationGroups";
+const _DGRGi = "DisassociateGlobalReplicationGroup";
+const _DNGIGRG = "DecreaseNodeGroupsInGlobalReplicationGroup";
+const _DNGIGRGM = "DecreaseNodeGroupsInGlobalReplicationGroupMessage";
+const _DNGIGRGR = "DecreaseNodeGroupsInGlobalReplicationGroupResult";
+const _DO = "DefaultOnly";
+const _DRC = "DecreaseReplicaCount";
+const _DRCM = "DecreaseReplicaCountMessage";
+const _DRCN = "DescribeReservedCacheNodes";
+const _DRCNM = "DescribeReservedCacheNodesMessage";
+const _DRCNO = "DescribeReservedCacheNodesOfferings";
+const _DRCNOM = "DescribeReservedCacheNodesOfferingsMessage";
+const _DRCR = "DecreaseReplicaCountResult";
+const _DRG = "DeleteReplicationGroup";
+const _DRGM = "DeleteReplicationGroupMessage";
+const _DRGMe = "DescribeReplicationGroupsMessage";
+const _DRGR = "DeleteReplicationGroupResult";
+const _DRGe = "DescribeReplicationGroups";
+const _DS = "DataStorage";
+const _DSC = "DeleteServerlessCache";
+const _DSCR = "DeleteServerlessCacheRequest";
+const _DSCRe = "DeleteServerlessCacheResponse";
+const _DSCRes = "DescribeServerlessCachesRequest";
+const _DSCResc = "DescribeServerlessCachesResponse";
+const _DSCS = "DeleteServerlessCacheSnapshot";
+const _DSCSR = "DeleteServerlessCacheSnapshotRequest";
+const _DSCSRe = "DeleteServerlessCacheSnapshotResponse";
+const _DSCSRes = "DescribeServerlessCacheSnapshotsRequest";
+const _DSCSResc = "DescribeServerlessCacheSnapshotsResponse";
+const _DSCSe = "DescribeServerlessCacheSnapshots";
+const _DSCe = "DescribeServerlessCaches";
+const _DSLM = "DescribeSnapshotsListMessage";
+const _DSM = "DeleteSnapshotMessage";
+const _DSMe = "DescribeSnapshotsMessage";
+const _DSR = "DeleteSnapshotResult";
+const _DST = "DailySnapshotTime";
+const _DSU = "DescribeServiceUpdates";
+const _DSUM = "DescribeServiceUpdatesMessage";
+const _DSe = "DeliveryStream";
+const _DSel = "DeleteSnapshot";
+const _DSes = "DescribeSnapshots";
+const _DT = "DataType";
+const _DTE = "DataTieringEnabled";
+const _DTa = "DataTiering";
+const _DTe = "DestinationType";
+const _DU = "DeleteUser";
+const _DUA = "DescribeUpdateActions";
+const _DUAM = "DescribeUpdateActionsMessage";
+const _DUATUGF = "DefaultUserAssociatedToUserGroupFault";
+const _DUG = "DeleteUserGroup";
+const _DUGM = "DeleteUserGroupMessage";
+const _DUGMe = "DescribeUserGroupsMessage";
+const _DUGR = "DescribeUserGroupsResult";
+const _DUGe = "DescribeUserGroups";
+const _DUM = "DeleteUserMessage";
+const _DUMe = "DescribeUsersMessage";
+const _DUNF = "DuplicateUserNameFault";
+const _DUR = "DefaultUserRequired";
+const _DURe = "DescribeUsersResult";
+const _DUe = "DescribeUsers";
+const _Da = "Date";
+const _Du = "Durability";
+const _Dur = "Duration";
+const _E = "Engine";
+const _ECPUPS = "ECPUPerSecond";
+const _ECSG = "EC2SecurityGroups";
+const _ECSGL = "EC2SecurityGroupList";
+const _ECSGN = "EC2SecurityGroupName";
+const _ECSGOI = "EC2SecurityGroupOwnerId";
+const _ECSGe = "EC2SecurityGroup";
+const _ED = "EngineDefaults";
+const _EDf = "EffectiveDurability";
+const _EL = "EventList";
+const _EM = "EventsMessage";
+const _EMr = "ErrorMessage";
+const _ESCS = "ExportServerlessCacheSnapshot";
+const _ESCSR = "ExportServerlessCacheSnapshotRequest";
+const _ESCSRx = "ExportServerlessCacheSnapshotResponse";
+const _ET = "EndTime";
+const _ETr = "ErrorType";
+const _ETx = "ExpiryTime";
+const _EUT = "EstimatedUpdateTime";
+const _EV = "EngineVersion";
+const _En = "Endpoint";
+const _Ena = "Enabled";
+const _Ev = "Event";
+const _Eve = "Events";
+const _F = "Force";
+const _FEV = "FullEngineVersion";
+const _FGRG = "FailoverGlobalReplicationGroup";
+const _FGRGM = "FailoverGlobalReplicationGroupMessage";
+const _FGRGR = "FailoverGlobalReplicationGroupResult";
+const _FL = "FilterList";
+const _FP = "FixedPrice";
+const _FSI = "FinalSnapshotIdentifier";
+const _FSN = "FinalSnapshotName";
+const _Fi = "Filters";
+const _Fil = "Filter";
+const _GNG = "GlobalNodeGroup";
+const _GNGI = "GlobalNodeGroupId";
+const _GNGIL = "GlobalNodeGroupIdList";
+const _GNGL = "GlobalNodeGroupList";
+const _GNGTR = "GlobalNodeGroupsToRemove";
+const _GNGTRl = "GlobalNodeGroupsToRetain";
+const _GNGl = "GlobalNodeGroups";
+const _GRG = "GlobalReplicationGroup";
+const _GRGAEF = "GlobalReplicationGroupAlreadyExistsFault";
+const _GRGD = "GlobalReplicationGroupDescription";
+const _GRGI = "GlobalReplicationGroupId";
+const _GRGIS = "GlobalReplicationGroupIdSuffix";
+const _GRGIl = "GlobalReplicationGroupInfo";
+const _GRGL = "GlobalReplicationGroupList";
+const _GRGM = "GlobalReplicationGroupMember";
+const _GRGML = "GlobalReplicationGroupMemberList";
+const _GRGMR = "GlobalReplicationGroupMemberRole";
+const _GRGNFF = "GlobalReplicationGroupNotFoundFault";
+const _GRGl = "GlobalReplicationGroups";
+const _IARNF = "InvalidARNFault";
+const _ICCCF = "InsufficientCacheClusterCapacityFault";
+const _ICCSF = "InvalidCacheClusterStateFault";
+const _ICE = "InvalidCredentialsException";
+const _ICPGSF = "InvalidCacheParameterGroupStateFault";
+const _ICSGSF = "InvalidCacheSecurityGroupStateFault";
+const _ID = "IpDiscovery";
+const _IG = "IsGlobal";
+const _IGRGSF = "InvalidGlobalReplicationGroupStateFault";
+const _IKMSKF = "InvalidKMSKeyFault";
+const _IM = "IsModifiable";
+const _INGIGRG = "IncreaseNodeGroupsInGlobalReplicationGroup";
+const _INGIGRGM = "IncreaseNodeGroupsInGlobalReplicationGroupMessage";
+const _INGIGRGR = "IncreaseNodeGroupsInGlobalReplicationGroupResult";
+const _IPCE = "InvalidParameterCombinationException";
+const _IPVE = "InvalidParameterValueException";
+const _IRC = "IncreaseReplicaCount";
+const _IRCM = "IncreaseReplicaCountMessage";
+const _IRCR = "IncreaseReplicaCountResult";
+const _IRGSF = "InvalidReplicationGroupStateFault";
+const _IS = "InvalidSubnet";
+const _ISCSF = "InvalidServerlessCacheStateFault";
+const _ISCSSF = "InvalidServerlessCacheSnapshotStateFault";
+const _ISSF = "InvalidSnapshotStateFault";
+const _IUGSF = "InvalidUserGroupStateFault";
+const _IUSF = "InvalidUserStateFault";
+const _IVPCNSF = "InvalidVPCNetworkStateFault";
+const _K = "Key";
+const _KFD = "KinesisFirehoseDetails";
+const _KFDD = "KinesisFirehoseDestinationDetails";
+const _KKI = "KmsKeyId";
+const _LANTM = "ListAllowedNodeTypeModifications";
+const _LANTMM = "ListAllowedNodeTypeModificationsMessage";
+const _LDC = "LogDeliveryConfigurations";
+const _LDCL = "LogDeliveryConfigurationList";
+const _LDCR = "LogDeliveryConfigurationRequest";
+const _LDCRL = "LogDeliveryConfigurationRequestList";
+const _LDCo = "LogDeliveryConfiguration";
+const _LF = "LogFormat";
+const _LG = "LogGroup";
+const _LT = "LogType";
+const _LTFR = "ListTagsForResource";
+const _LTFRM = "ListTagsForResourceMessage";
+const _M = "Marker";
+const _MAZ = "MultiAZ";
+const _MAZE = "MultiAZEnabled";
+const _MC = "MemberClusters";
+const _MCC = "ModifyCacheCluster";
+const _MCCM = "ModifyCacheClusterMessage";
+const _MCCR = "ModifyCacheClusterResult";
+const _MCOA = "MemberClustersOutpostArns";
+const _MCPG = "ModifyCacheParameterGroup";
+const _MCPGM = "ModifyCacheParameterGroupMessage";
+const _MCSG = "ModifyCacheSubnetGroup";
+const _MCSGM = "ModifyCacheSubnetGroupMessage";
+const _MCSGR = "ModifyCacheSubnetGroupResult";
+const _MEV = "MinimumEngineVersion";
+const _MEVa = "MajorEngineVersion";
+const _MGRG = "ModifyGlobalReplicationGroup";
+const _MGRGM = "ModifyGlobalReplicationGroupMessage";
+const _MGRGR = "ModifyGlobalReplicationGroupResult";
+const _MR = "MaxRecords";
+const _MRG = "ModifyReplicationGroup";
+const _MRGM = "ModifyReplicationGroupMessage";
+const _MRGR = "ModifyReplicationGroupResult";
+const _MRGSC = "ModifyReplicationGroupShardConfiguration";
+const _MRGSCM = "ModifyReplicationGroupShardConfigurationMessage";
+const _MRGSCR = "ModifyReplicationGroupShardConfigurationResult";
+const _MRa = "MaxResults";
+const _MSC = "ModifyServerlessCache";
+const _MSCR = "ModifyServerlessCacheRequest";
+const _MSCRo = "ModifyServerlessCacheResponse";
+const _MU = "ModifyUser";
+const _MUG = "ModifyUserGroup";
+const _MUGM = "ModifyUserGroupMessage";
+const _MUM = "ModifyUserMessage";
+const _Ma = "Maximum";
+const _Me = "Message";
+const _Mem = "Members";
+const _Mi = "Minimum";
+const _N = "Name";
+const _NAZ = "NewAvailabilityZones";
+const _NC = "NotificationConfiguration";
+const _NCC = "NumCacheClusters";
+const _NCN = "NumCacheNodes";
+const _NDD = "NodeDeletionDate";
+const _NG = "NodeGroup";
+const _NGC = "NodeGroupConfiguration";
+const _NGCL = "NodeGroupConfigurationList";
+const _NGCo = "NodeGroupCount";
+const _NGI = "NodeGroupId";
+const _NGL = "NodeGroupList";
+const _NGM = "NodeGroupMembers";
+const _NGML = "NodeGroupMemberList";
+const _NGMUS = "NodeGroupMemberUpdateStatus";
+const _NGMUSL = "NodeGroupMemberUpdateStatusList";
+const _NGMo = "NodeGroupMember";
+const _NGNFF = "NodeGroupNotFoundFault";
+const _NGPRGQEF = "NodeGroupsPerReplicationGroupQuotaExceededFault";
+const _NGTR = "NodeGroupsToRemove";
+const _NGTRL = "NodeGroupsToRemoveList";
+const _NGTRLo = "NodeGroupsToRetainList";
+const _NGTRo = "NodeGroupsToRetain";
+const _NGTRod = "NodeGroupToRemove";
+const _NGTRode = "NodeGroupToRetain";
+const _NGUS = "NodeGroupUpdateStatus";
+const _NGUSL = "NodeGroupUpdateStatusList";
+const _NGo = "NodeGroups";
+const _NNG = "NumNodeGroups";
+const _NOF = "NoOperationFault";
+const _NPR = "NoPasswordRequired";
+const _NQFCEF = "NodeQuotaForClusterExceededFault";
+const _NQFCEFo = "NodeQuotaForCustomerExceededFault";
+const _NRC = "NewReplicaCount";
+const _NS = "NodeSnapshot";
+const _NSL = "NodeSnapshotList";
+const _NSo = "NodeSnapshots";
+const _NT = "NetworkType";
+const _NTA = "NotificationTopicArn";
+const _NTS = "NotificationTopicStatus";
+const _NTe = "NextToken";
+const _NU = "NodesUpdated";
+const _NUED = "NodeUpdateEndDate";
+const _NUIB = "NodeUpdateInitiatedBy";
+const _NUID = "NodeUpdateInitiatedDate";
+const _NUS = "NodeUpdateStatus";
+const _NUSD = "NodeUpdateStartDate";
+const _NUSMD = "NodeUpdateStatusModifiedDate";
+const _OA = "OutpostArn";
+const _OAL = "OutpostArnsList";
+const _OI = "OwnerId";
+const _OM = "OutpostMode";
+const _OT = "OfferingType";
+const _P = "Passwords";
+const _PAS = "ParameterApplyStatus";
+const _PAZ = "PreferredAvailabilityZone";
+const _PAZL = "PreferredAvailabilityZoneList";
+const _PAZr = "PreferredAvailabilityZones";
+const _PAZri = "PrimaryAvailabilityZone";
+const _PC = "PasswordCount";
+const _PCCAZ = "PreferredCacheClusterAZs";
+const _PCI = "PrimaryClusterId";
+const _PCe = "PendingChanges";
+const _PD = "ProductDescription";
+const _PE = "PrimaryEndpoint";
+const _PGS = "ParameterGroupStatus";
+const _PL = "ParametersList";
+const _PLDC = "PendingLogDeliveryConfiguration";
+const _PLDCL = "PendingLogDeliveryConfigurationList";
+const _PMV = "PendingModifiedValues";
+const _PMW = "PreferredMaintenanceWindow";
+const _PN = "ParameterName";
+const _PNV = "ParameterNameValues";
+const _PNVL = "ParameterNameValueList";
+const _PNVa = "ParameterNameValue";
+const _POA = "PreferredOutpostArn";
+const _POAL = "PreferredOutpostArnList";
+const _POAr = "PreferredOutpostArns";
+const _POAri = "PrimaryOutpostArn";
+const _PP = "ProgressPercentage";
+const _PR = "PrimaryRegion";
+const _PRCNO = "PurchaseReservedCacheNodesOffering";
+const _PRCNOM = "PurchaseReservedCacheNodesOfferingMessage";
+const _PRCNOR = "PurchaseReservedCacheNodesOfferingResult";
+const _PRGI = "PrimaryReplicationGroupId";
+const _PUA = "ProcessedUpdateAction";
+const _PUAL = "ProcessedUpdateActionList";
+const _PUAr = "ProcessedUpdateActions";
+const _PV = "ParameterValue";
+const _Pa = "Parameters";
+const _Par = "Parameter";
+const _Po = "Port";
+const _R = "Role";
+const _RAP = "ResetAllParameters";
+const _RARN = "ReservationARN";
+const _RAZ = "ReplicaAvailabilityZones";
+const _RC = "ReplicaConfiguration";
+const _RCA = "RecurringChargeAmount";
+const _RCC = "RebootCacheCluster";
+const _RCCM = "RebootCacheClusterMessage";
+const _RCCR = "RebootCacheClusterResult";
+const _RCF = "RecurringChargeFrequency";
+const _RCL = "RecurringChargeList";
+const _RCLe = "RegionalConfigurationList";
+const _RCLep = "ReplicaConfigurationList";
+const _RCLes = "ReshardingConfigurationList";
+const _RCN = "ReservedCacheNode";
+const _RCNAEF = "ReservedCacheNodeAlreadyExistsFault";
+const _RCNI = "ReservedCacheNodeId";
+const _RCNL = "ReservedCacheNodeList";
+const _RCNM = "ReservedCacheNodeMessage";
+const _RCNNFF = "ReservedCacheNodeNotFoundFault";
+const _RCNO = "ReservedCacheNodesOffering";
+const _RCNOI = "ReservedCacheNodesOfferingId";
+const _RCNOL = "ReservedCacheNodesOfferingList";
+const _RCNOM = "ReservedCacheNodesOfferingMessage";
+const _RCNONFF = "ReservedCacheNodesOfferingNotFoundFault";
+const _RCNOe = "ReservedCacheNodesOfferings";
+const _RCNQEF = "ReservedCacheNodeQuotaExceededFault";
+const _RCNe = "ReservedCacheNodes";
+const _RCPG = "ResetCacheParameterGroup";
+const _RCPGM = "ResetCacheParameterGroupMessage";
+const _RCSGI = "RevokeCacheSecurityGroupIngress";
+const _RCSGIM = "RevokeCacheSecurityGroupIngressMessage";
+const _RCSGIR = "RevokeCacheSecurityGroupIngressResult";
+const _RCe = "RegionalConfigurations";
+const _RCec = "RecurringCharge";
+const _RCecu = "RecurringCharges";
+const _RCeg = "RegionalConfiguration";
+const _RCep = "ReplicaCount";
+const _RCes = "ReshardingConfiguration";
+const _RE = "ReaderEndpoint";
+const _REe = "ReadEndpoint";
+const _RG = "ReplicationGroup";
+const _RGAEF = "ReplicationGroupAlreadyExistsFault";
+const _RGAUMF = "ReplicationGroupAlreadyUnderMigrationFault";
+const _RGCT = "ReplicationGroupCreateTime";
+const _RGD = "ReplicationGroupDescription";
+const _RGI = "ReplicationGroupIds";
+const _RGIe = "ReplicationGroupId";
+const _RGL = "ReplicationGroupList";
+const _RGLDE = "ReplicationGroupLogDeliveryEnabled";
+const _RGM = "ReplicationGroupMessage";
+const _RGNFF = "ReplicationGroupNotFoundFault";
+const _RGNUMF = "ReplicationGroupNotUnderMigrationFault";
+const _RGOA = "ReplicationGroupOutpostArn";
+const _RGOAL = "ReplicationGroupOutpostArnList";
+const _RGPMV = "ReplicationGroupPendingModifiedValues";
+const _RGR = "ReplicationGroupRegion";
+const _RGe = "ReplicationGroups";
+const _RN = "ResourceName";
+const _ROA = "ReplicaOutpostArns";
+const _RPC = "RetainPrimaryCluster";
+const _RPNG = "ReplicasPerNodeGroup";
+const _RPRG = "RetainPrimaryReplicationGroup";
+const _RS = "ReshardingStatus";
+const _RSIGRG = "RebalanceSlotsInGlobalReplicationGroup";
+const _RSIGRGM = "RebalanceSlotsInGlobalReplicationGroupMessage";
+const _RSIGRGR = "RebalanceSlotsInGlobalReplicationGroupResult";
+const _RTFR = "RemoveTagsFromResource";
+const _RTFRM = "RemoveTagsFromResourceMessage";
+const _RTR = "ReplicasToRemove";
+const _RUG = "RemoveUserGroups";
+const _RUGe = "RemoveUserGroup";
+const _Re = "Resharding";
+const _S = "Source";
+const _SA = "SnapshotArns";
+const _SAEF = "SnapshotAlreadyExistsFault";
+const _SAL = "SnapshotArnsList";
+const _SATR = "SnapshotArnsToRestore";
+const _SAZ = "SubnetAvailabilityZone";
+const _SAn = "SnapshotArn";
+const _SBN = "S3BucketName";
+const _SC = "ServerlessCache";
+const _SCAEF = "ServerlessCacheAlreadyExistsFault";
+const _SCC = "ServerlessCacheConfiguration";
+const _SCCNIRG = "ShowCacheClustersNotInReplicationGroups";
+const _SCI = "SnapshottingClusterId";
+const _SCL = "ServerlessCacheList";
+const _SCN = "ServerlessCacheName";
+const _SCNFF = "ServerlessCacheNotFoundFault";
+const _SCNI = "SourceCacheNodeId";
+const _SCNIh = "ShowCacheNodeInfo";
+const _SCQFCEF = "ServerlessCacheQuotaForCustomerExceededFault";
+const _SCS = "ServerlessCacheSnapshot";
+const _SCSAEF = "ServerlessCacheSnapshotAlreadyExistsFault";
+const _SCSL = "ServerlessCacheSnapshotList";
+const _SCSN = "ServerlessCacheSnapshotName";
+const _SCSNFF = "ServerlessCacheSnapshotNotFoundFault";
+const _SCSQEF = "ServerlessCacheSnapshotQuotaExceededFault";
+const _SCSe = "ServerlessCacheSnapshots";
+const _SCT = "SnapshotCreateTime";
+const _SCc = "ScaleConfig";
+const _SCe = "ServerlessCaches";
+const _SDM = "ScaleDownModifications";
+const _SET = "StorageEncryptionType";
+const _SFNSF = "SnapshotFeatureNotSupportedFault";
+const _SG = "SecurityGroups";
+const _SGI = "SecurityGroupIds";
+const _SGIL = "SecurityGroupIdsList";
+const _SGIe = "SecurityGroupId";
+const _SGM = "SecurityGroupMembership";
+const _SGML = "SecurityGroupMembershipList";
+const _SI = "SubnetIds";
+const _SIL = "SubnetIdentifierList";
+const _SILu = "SubnetIdsList";
+const _SIM = "ScaleIntervalMinutes";
+const _SIU = "SubnetInUse";
+const _SIo = "SourceIdentifier";
+const _SIu = "SubnetIdentifier";
+const _SIub = "SubnetId";
+const _SL = "SnapshotList";
+const _SLRNFF = "ServiceLinkedRoleNotFoundFault";
+const _SLu = "SubnetList";
+const _SM = "SlotMigration";
+const _SMI = "ShowMemberInfo";
+const _SMM = "StartMigrationMessage";
+const _SMR = "StartMigrationResponse";
+const _SMl = "SlaMet";
+const _SMt = "StartMigration";
+const _SN = "SnapshotName";
+const _SNAF = "SubnetNotAllowedFault";
+const _SNFF = "SnapshotNotFoundFault";
+const _SNGC = "ShowNodeGroupConfig";
+const _SNLUS = "ShowNodeLevelUpdateStatus";
+const _SNT = "SupportedNetworkTypes";
+const _SO = "SubnetOutpost";
+const _SOA = "SubnetOutpostArn";
+const _SP = "ScalePercentage";
+const _SQEF = "SnapshotQuotaExceededFault";
+const _SRL = "SnapshotRetentionLimit";
+const _SS = "SnapshotSource";
+const _SSCSN = "SourceServerlessCacheSnapshotName";
+const _SSN = "SourceSnapshotName";
+const _SSn = "SnapshotStatus";
+const _ST = "SourceType";
+const _STn = "SnapshotType";
+const _STt = "StartTime";
+const _SU = "ServiceUpdate";
+const _SUD = "ServiceUpdateDescription";
+const _SUED = "ServiceUpdateEndDate";
+const _SUL = "ServiceUpdateList";
+const _SUM = "ScaleUpModifications";
+const _SUMe = "ServiceUpdatesMessage";
+const _SUN = "ServiceUpdateName";
+const _SUNFF = "ServiceUpdateNotFoundFault";
+const _SURABD = "ServiceUpdateRecommendedApplyByDate";
+const _SURD = "ServiceUpdateReleaseDate";
+const _SUS = "ServiceUpdateStatus";
+const _SUSe = "ServiceUpdateSeverity";
+const _SUT = "ServiceUpdateType";
+const _SUTR = "ServiceUpdateTimeRange";
+const _SUe = "ServiceUpdates";
+const _SW = "SnapshotWindow";
+const _Sl = "Slots";
+const _Sn = "Snapshot";
+const _Sna = "Snapshots";
+const _St = "Status";
+const _Sta = "State";
+const _Su = "Subnets";
+const _Sub = "Subnet";
+const _T = "Tags";
+const _TA = "TopicArn";
+const _TB = "TargetBucket";
+const _TEE = "TransitEncryptionEnabled";
+const _TEM = "TransitEncryptionMode";
+const _TF = "TestFailover";
+const _TFM = "TestFailoverMessage";
+const _TFNAF = "TestFailoverNotAvailableFault";
+const _TFR = "TestFailoverResult";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TLM = "TagListMessage";
+const _TM = "TestMigration";
+const _TMM = "TestMigrationMessage";
+const _TMR = "TestMigrationResponse";
+const _TNFF = "TagNotFoundFault";
+const _TQPRE = "TagQuotaPerResourceExceeded";
+const _TRF = "TimeRangeFilter";
+const _TS = "TopicStatus";
+const _TSCSN = "TargetServerlessCacheSnapshotName";
+const _TSN = "TargetSnapshotName";
+const _Ta = "Tag";
+const _Ty = "Type";
+const _U = "Unit";
+const _UA = "UpdateAction";
+const _UAAD = "UpdateActionAvailableDate";
+const _UAEF = "UserAlreadyExistsFault";
+const _UAL = "UpdateActionList";
+const _UAM = "UpdateActionsMessage";
+const _UARM = "UpdateActionResultsMessage";
+const _UAS = "UpdateActionStatus";
+const _UASMD = "UpdateActionStatusModifiedDate";
+const _UAp = "UpdateActions";
+const _UG = "UserGroups";
+const _UGAEF = "UserGroupAlreadyExistsFault";
+const _UGI = "UserGroupIds";
+const _UGITA = "UserGroupIdsToAdd";
+const _UGITR = "UserGroupIdsToRemove";
+const _UGIs = "UserGroupId";
+const _UGL = "UserGroupList";
+const _UGNFF = "UserGroupNotFoundFault";
+const _UGPC = "UserGroupPendingChanges";
+const _UGQEF = "UserGroupQuotaExceededFault";
+const _UGUS = "UserGroupsUpdateStatus";
+const _UGs = "UserGroup";
+const _UI = "UserIds";
+const _UITA = "UserIdsToAdd";
+const _UITR = "UserIdsToRemove";
+const _UIs = "UserId";
+const _UL = "UserList";
+const _UN = "UserName";
+const _UNFF = "UserNotFoundFault";
+const _UP = "UsagePrice";
+const _UQEF = "UserQuotaExceededFault";
+const _UUA = "UnprocessedUpdateAction";
+const _UUAL = "UnprocessedUpdateActionList";
+const _UUAn = "UnprocessedUpdateActions";
+const _Us = "Users";
+const _Use = "User";
+const _V = "Value";
+const _VI = "VpcId";
+const _Va = "Values";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.elasticache";
+const _xN = "xmlName";
+const n0 = "com.amazonaws.elasticache";
+const _s_registry = TypeRegistry.for(_s);
+var ElastiCacheServiceException$ = [-3, _s, "ElastiCacheServiceException", 0, [], []];
+_s_registry.registerError(ElastiCacheServiceException$, ElastiCacheServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var APICallRateForCustomerExceededFault$ = [-3, n0, _APICRFCEF,
+    { [_aQE]: [`APICallRateForCustomerExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(APICallRateForCustomerExceededFault$, APICallRateForCustomerExceededFault);
+var AuthorizationAlreadyExistsFault$ = [-3, n0, _AAEF,
+    { [_aQE]: [`AuthorizationAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(AuthorizationAlreadyExistsFault$, AuthorizationAlreadyExistsFault);
+var AuthorizationNotFoundFault$ = [-3, n0, _ANFF,
+    { [_aQE]: [`AuthorizationNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(AuthorizationNotFoundFault$, AuthorizationNotFoundFault);
+var CacheClusterAlreadyExistsFault$ = [-3, n0, _CCAEF,
+    { [_aQE]: [`CacheClusterAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheClusterAlreadyExistsFault$, CacheClusterAlreadyExistsFault);
+var CacheClusterNotFoundFault$ = [-3, n0, _CCNFF,
+    { [_aQE]: [`CacheClusterNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheClusterNotFoundFault$, CacheClusterNotFoundFault);
+var CacheParameterGroupAlreadyExistsFault$ = [-3, n0, _CPGAEF,
+    { [_aQE]: [`CacheParameterGroupAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheParameterGroupAlreadyExistsFault$, CacheParameterGroupAlreadyExistsFault);
+var CacheParameterGroupNotFoundFault$ = [-3, n0, _CPGNFF,
+    { [_aQE]: [`CacheParameterGroupNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheParameterGroupNotFoundFault$, CacheParameterGroupNotFoundFault);
+var CacheParameterGroupQuotaExceededFault$ = [-3, n0, _CPGQEF,
+    { [_aQE]: [`CacheParameterGroupQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheParameterGroupQuotaExceededFault$, CacheParameterGroupQuotaExceededFault);
+var CacheSecurityGroupAlreadyExistsFault$ = [-3, n0, _CSGAEF,
+    { [_aQE]: [`CacheSecurityGroupAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSecurityGroupAlreadyExistsFault$, CacheSecurityGroupAlreadyExistsFault);
+var CacheSecurityGroupNotFoundFault$ = [-3, n0, _CSGNFF,
+    { [_aQE]: [`CacheSecurityGroupNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSecurityGroupNotFoundFault$, CacheSecurityGroupNotFoundFault);
+var CacheSecurityGroupQuotaExceededFault$ = [-3, n0, _CSGQEF,
+    { [_aQE]: [`QuotaExceeded.CacheSecurityGroup`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSecurityGroupQuotaExceededFault$, CacheSecurityGroupQuotaExceededFault);
+var CacheSubnetGroupAlreadyExistsFault$ = [-3, n0, _CSGAEFa,
+    { [_aQE]: [`CacheSubnetGroupAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSubnetGroupAlreadyExistsFault$, CacheSubnetGroupAlreadyExistsFault);
+var CacheSubnetGroupInUse$ = [-3, n0, _CSGIU,
+    { [_aQE]: [`CacheSubnetGroupInUse`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSubnetGroupInUse$, CacheSubnetGroupInUse);
+var CacheSubnetGroupNotFoundFault$ = [-3, n0, _CSGNFFa,
+    { [_aQE]: [`CacheSubnetGroupNotFoundFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSubnetGroupNotFoundFault$, CacheSubnetGroupNotFoundFault);
+var CacheSubnetGroupQuotaExceededFault$ = [-3, n0, _CSGQEFa,
+    { [_aQE]: [`CacheSubnetGroupQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSubnetGroupQuotaExceededFault$, CacheSubnetGroupQuotaExceededFault);
+var CacheSubnetQuotaExceededFault$ = [-3, n0, _CSQEF,
+    { [_aQE]: [`CacheSubnetQuotaExceededFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(CacheSubnetQuotaExceededFault$, CacheSubnetQuotaExceededFault);
+var ClusterQuotaForCustomerExceededFault$ = [-3, n0, _CQFCEF,
+    { [_aQE]: [`ClusterQuotaForCustomerExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ClusterQuotaForCustomerExceededFault$, ClusterQuotaForCustomerExceededFault);
+var DefaultUserAssociatedToUserGroupFault$ = [-3, n0, _DUATUGF,
+    { [_aQE]: [`DefaultUserAssociatedToUserGroup`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DefaultUserAssociatedToUserGroupFault$, DefaultUserAssociatedToUserGroupFault);
+var DefaultUserRequired$ = [-3, n0, _DUR,
+    { [_aQE]: [`DefaultUserRequired`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DefaultUserRequired$, DefaultUserRequired);
+var DuplicateUserNameFault$ = [-3, n0, _DUNF,
+    { [_aQE]: [`DuplicateUserName`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DuplicateUserNameFault$, DuplicateUserNameFault);
+var GlobalReplicationGroupAlreadyExistsFault$ = [-3, n0, _GRGAEF,
+    { [_aQE]: [`GlobalReplicationGroupAlreadyExistsFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(GlobalReplicationGroupAlreadyExistsFault$, GlobalReplicationGroupAlreadyExistsFault);
+var GlobalReplicationGroupNotFoundFault$ = [-3, n0, _GRGNFF,
+    { [_aQE]: [`GlobalReplicationGroupNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(GlobalReplicationGroupNotFoundFault$, GlobalReplicationGroupNotFoundFault);
+var InsufficientCacheClusterCapacityFault$ = [-3, n0, _ICCCF,
+    { [_aQE]: [`InsufficientCacheClusterCapacity`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InsufficientCacheClusterCapacityFault$, InsufficientCacheClusterCapacityFault);
+var InvalidARNFault$ = [-3, n0, _IARNF,
+    { [_aQE]: [`InvalidARN`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidARNFault$, InvalidARNFault);
+var InvalidCacheClusterStateFault$ = [-3, n0, _ICCSF,
+    { [_aQE]: [`InvalidCacheClusterState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidCacheClusterStateFault$, InvalidCacheClusterStateFault);
+var InvalidCacheParameterGroupStateFault$ = [-3, n0, _ICPGSF,
+    { [_aQE]: [`InvalidCacheParameterGroupState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidCacheParameterGroupStateFault$, InvalidCacheParameterGroupStateFault);
+var InvalidCacheSecurityGroupStateFault$ = [-3, n0, _ICSGSF,
+    { [_aQE]: [`InvalidCacheSecurityGroupState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidCacheSecurityGroupStateFault$, InvalidCacheSecurityGroupStateFault);
+var InvalidCredentialsException$ = [-3, n0, _ICE,
+    { [_aQE]: [`InvalidCredentialsException`, 408], [_e]: _c, [_hE]: 408 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidCredentialsException$, InvalidCredentialsException);
+var InvalidGlobalReplicationGroupStateFault$ = [-3, n0, _IGRGSF,
+    { [_aQE]: [`InvalidGlobalReplicationGroupState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidGlobalReplicationGroupStateFault$, InvalidGlobalReplicationGroupStateFault);
+var InvalidKMSKeyFault$ = [-3, n0, _IKMSKF,
+    { [_aQE]: [`InvalidKMSKeyFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidKMSKeyFault$, InvalidKMSKeyFault);
+var InvalidParameterCombinationException$ = [-3, n0, _IPCE,
+    { [_aQE]: [`InvalidParameterCombination`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidParameterCombinationException$, InvalidParameterCombinationException);
+var InvalidParameterValueException$ = [-3, n0, _IPVE,
+    { [_aQE]: [`InvalidParameterValue`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidParameterValueException$, InvalidParameterValueException);
+var InvalidReplicationGroupStateFault$ = [-3, n0, _IRGSF,
+    { [_aQE]: [`InvalidReplicationGroupState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidReplicationGroupStateFault$, InvalidReplicationGroupStateFault);
+var InvalidServerlessCacheSnapshotStateFault$ = [-3, n0, _ISCSSF,
+    { [_aQE]: [`InvalidServerlessCacheSnapshotStateFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidServerlessCacheSnapshotStateFault$, InvalidServerlessCacheSnapshotStateFault);
+var InvalidServerlessCacheStateFault$ = [-3, n0, _ISCSF,
+    { [_aQE]: [`InvalidServerlessCacheStateFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidServerlessCacheStateFault$, InvalidServerlessCacheStateFault);
+var InvalidSnapshotStateFault$ = [-3, n0, _ISSF,
+    { [_aQE]: [`InvalidSnapshotState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSnapshotStateFault$, InvalidSnapshotStateFault);
+var InvalidSubnet$ = [-3, n0, _IS,
+    { [_aQE]: [`InvalidSubnet`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSubnet$, InvalidSubnet);
+var InvalidUserGroupStateFault$ = [-3, n0, _IUGSF,
+    { [_aQE]: [`InvalidUserGroupState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidUserGroupStateFault$, InvalidUserGroupStateFault);
+var InvalidUserStateFault$ = [-3, n0, _IUSF,
+    { [_aQE]: [`InvalidUserState`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidUserStateFault$, InvalidUserStateFault);
+var InvalidVPCNetworkStateFault$ = [-3, n0, _IVPCNSF,
+    { [_aQE]: [`InvalidVPCNetworkStateFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidVPCNetworkStateFault$, InvalidVPCNetworkStateFault);
+var NodeGroupNotFoundFault$ = [-3, n0, _NGNFF,
+    { [_aQE]: [`NodeGroupNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NodeGroupNotFoundFault$, NodeGroupNotFoundFault);
+var NodeGroupsPerReplicationGroupQuotaExceededFault$ = [-3, n0, _NGPRGQEF,
+    { [_aQE]: [`NodeGroupsPerReplicationGroupQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NodeGroupsPerReplicationGroupQuotaExceededFault$, NodeGroupsPerReplicationGroupQuotaExceededFault);
+var NodeQuotaForClusterExceededFault$ = [-3, n0, _NQFCEF,
+    { [_aQE]: [`NodeQuotaForClusterExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NodeQuotaForClusterExceededFault$, NodeQuotaForClusterExceededFault);
+var NodeQuotaForCustomerExceededFault$ = [-3, n0, _NQFCEFo,
+    { [_aQE]: [`NodeQuotaForCustomerExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NodeQuotaForCustomerExceededFault$, NodeQuotaForCustomerExceededFault);
+var NoOperationFault$ = [-3, n0, _NOF,
+    { [_aQE]: [`NoOperationFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(NoOperationFault$, NoOperationFault);
+var ReplicationGroupAlreadyExistsFault$ = [-3, n0, _RGAEF,
+    { [_aQE]: [`ReplicationGroupAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReplicationGroupAlreadyExistsFault$, ReplicationGroupAlreadyExistsFault);
+var ReplicationGroupAlreadyUnderMigrationFault$ = [-3, n0, _RGAUMF,
+    { [_aQE]: [`ReplicationGroupAlreadyUnderMigrationFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReplicationGroupAlreadyUnderMigrationFault$, ReplicationGroupAlreadyUnderMigrationFault);
+var ReplicationGroupNotFoundFault$ = [-3, n0, _RGNFF,
+    { [_aQE]: [`ReplicationGroupNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReplicationGroupNotFoundFault$, ReplicationGroupNotFoundFault);
+var ReplicationGroupNotUnderMigrationFault$ = [-3, n0, _RGNUMF,
+    { [_aQE]: [`ReplicationGroupNotUnderMigrationFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReplicationGroupNotUnderMigrationFault$, ReplicationGroupNotUnderMigrationFault);
+var ReservedCacheNodeAlreadyExistsFault$ = [-3, n0, _RCNAEF,
+    { [_aQE]: [`ReservedCacheNodeAlreadyExists`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReservedCacheNodeAlreadyExistsFault$, ReservedCacheNodeAlreadyExistsFault);
+var ReservedCacheNodeNotFoundFault$ = [-3, n0, _RCNNFF,
+    { [_aQE]: [`ReservedCacheNodeNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReservedCacheNodeNotFoundFault$, ReservedCacheNodeNotFoundFault);
+var ReservedCacheNodeQuotaExceededFault$ = [-3, n0, _RCNQEF,
+    { [_aQE]: [`ReservedCacheNodeQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReservedCacheNodeQuotaExceededFault$, ReservedCacheNodeQuotaExceededFault);
+var ReservedCacheNodesOfferingNotFoundFault$ = [-3, n0, _RCNONFF,
+    { [_aQE]: [`ReservedCacheNodesOfferingNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ReservedCacheNodesOfferingNotFoundFault$, ReservedCacheNodesOfferingNotFoundFault);
+var ServerlessCacheAlreadyExistsFault$ = [-3, n0, _SCAEF,
+    { [_aQE]: [`ServerlessCacheAlreadyExistsFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheAlreadyExistsFault$, ServerlessCacheAlreadyExistsFault);
+var ServerlessCacheNotFoundFault$ = [-3, n0, _SCNFF,
+    { [_aQE]: [`ServerlessCacheNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheNotFoundFault$, ServerlessCacheNotFoundFault);
+var ServerlessCacheQuotaForCustomerExceededFault$ = [-3, n0, _SCQFCEF,
+    { [_aQE]: [`ServerlessCacheQuotaForCustomerExceededFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheQuotaForCustomerExceededFault$, ServerlessCacheQuotaForCustomerExceededFault);
+var ServerlessCacheSnapshotAlreadyExistsFault$ = [-3, n0, _SCSAEF,
+    { [_aQE]: [`ServerlessCacheSnapshotAlreadyExistsFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheSnapshotAlreadyExistsFault$, ServerlessCacheSnapshotAlreadyExistsFault);
+var ServerlessCacheSnapshotNotFoundFault$ = [-3, n0, _SCSNFF,
+    { [_aQE]: [`ServerlessCacheSnapshotNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheSnapshotNotFoundFault$, ServerlessCacheSnapshotNotFoundFault);
+var ServerlessCacheSnapshotQuotaExceededFault$ = [-3, n0, _SCSQEF,
+    { [_aQE]: [`ServerlessCacheSnapshotQuotaExceededFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServerlessCacheSnapshotQuotaExceededFault$, ServerlessCacheSnapshotQuotaExceededFault);
+var ServiceLinkedRoleNotFoundFault$ = [-3, n0, _SLRNFF,
+    { [_aQE]: [`ServiceLinkedRoleNotFoundFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServiceLinkedRoleNotFoundFault$, ServiceLinkedRoleNotFoundFault);
+var ServiceUpdateNotFoundFault$ = [-3, n0, _SUNFF,
+    { [_aQE]: [`ServiceUpdateNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServiceUpdateNotFoundFault$, ServiceUpdateNotFoundFault);
+var SnapshotAlreadyExistsFault$ = [-3, n0, _SAEF,
+    { [_aQE]: [`SnapshotAlreadyExistsFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SnapshotAlreadyExistsFault$, SnapshotAlreadyExistsFault);
+var SnapshotFeatureNotSupportedFault$ = [-3, n0, _SFNSF,
+    { [_aQE]: [`SnapshotFeatureNotSupportedFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SnapshotFeatureNotSupportedFault$, SnapshotFeatureNotSupportedFault);
+var SnapshotNotFoundFault$ = [-3, n0, _SNFF,
+    { [_aQE]: [`SnapshotNotFoundFault`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SnapshotNotFoundFault$, SnapshotNotFoundFault);
+var SnapshotQuotaExceededFault$ = [-3, n0, _SQEF,
+    { [_aQE]: [`SnapshotQuotaExceededFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SnapshotQuotaExceededFault$, SnapshotQuotaExceededFault);
+var SubnetInUse$ = [-3, n0, _SIU,
+    { [_aQE]: [`SubnetInUse`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SubnetInUse$, SubnetInUse);
+var SubnetNotAllowedFault$ = [-3, n0, _SNAF,
+    { [_aQE]: [`SubnetNotAllowedFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SubnetNotAllowedFault$, SubnetNotAllowedFault);
+var TagNotFoundFault$ = [-3, n0, _TNFF,
+    { [_aQE]: [`TagNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagNotFoundFault$, TagNotFoundFault);
+var TagQuotaPerResourceExceeded$ = [-3, n0, _TQPRE,
+    { [_aQE]: [`TagQuotaPerResourceExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TagQuotaPerResourceExceeded$, TagQuotaPerResourceExceeded);
+var TestFailoverNotAvailableFault$ = [-3, n0, _TFNAF,
+    { [_aQE]: [`TestFailoverNotAvailableFault`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TestFailoverNotAvailableFault$, TestFailoverNotAvailableFault);
+var UserAlreadyExistsFault$ = [-3, n0, _UAEF,
+    { [_aQE]: [`UserAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserAlreadyExistsFault$, UserAlreadyExistsFault);
+var UserGroupAlreadyExistsFault$ = [-3, n0, _UGAEF,
+    { [_aQE]: [`UserGroupAlreadyExists`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserGroupAlreadyExistsFault$, UserGroupAlreadyExistsFault);
+var UserGroupNotFoundFault$ = [-3, n0, _UGNFF,
+    { [_aQE]: [`UserGroupNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserGroupNotFoundFault$, UserGroupNotFoundFault);
+var UserGroupQuotaExceededFault$ = [-3, n0, _UGQEF,
+    { [_aQE]: [`UserGroupQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserGroupQuotaExceededFault$, UserGroupQuotaExceededFault);
+var UserNotFoundFault$ = [-3, n0, _UNFF,
+    { [_aQE]: [`UserNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserNotFoundFault$, UserNotFoundFault);
+var UserQuotaExceededFault$ = [-3, n0, _UQEF,
+    { [_aQE]: [`UserQuotaExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UserQuotaExceededFault$, UserQuotaExceededFault);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var AddTagsToResourceMessage$ = [3, n0, _ATTRM,
+    0,
+    [_RN, _T],
+    [0, [() => TagList, 0]], 2
+];
+var AllowedNodeTypeModificationsMessage$ = [3, n0, _ANTMM,
+    0,
+    [_SUM, _SDM],
+    [64 | 0, 64 | 0]
+];
+var Authentication$ = [3, n0, _A,
+    0,
+    [_Ty, _PC],
+    [0, 1]
+];
+var AuthenticationMode$ = [3, n0, _AM,
+    0,
+    [_Ty, _P],
+    [0, 64 | 0]
+];
+var AuthorizeCacheSecurityGroupIngressMessage$ = [3, n0, _ACSGIM,
+    0,
+    [_CSGN, _ECSGN, _ECSGOI],
+    [0, 0, 0], 3
+];
+var AuthorizeCacheSecurityGroupIngressResult$ = [3, n0, _ACSGIR,
+    0,
+    [_CSG],
+    [[() => CacheSecurityGroup$, 0]]
+];
+var AvailabilityZone$ = [3, n0, _AZ,
+    0,
+    [_N],
+    [0]
+];
+var BatchApplyUpdateActionMessage$ = [3, n0, _BAUAM,
+    0,
+    [_SUN, _RGI, _CCI],
+    [0, 64 | 0, 64 | 0], 1
+];
+var BatchStopUpdateActionMessage$ = [3, n0, _BSUAM,
+    0,
+    [_SUN, _RGI, _CCI],
+    [0, 64 | 0, 64 | 0], 1
+];
+var CacheCluster$ = [3, n0, _CC,
+    0,
+    [_CCIa, _CE, _CDLP, _CNT, _E, _EV, _CCS, _NCN, _PAZ, _POA, _CCCT, _PMW, _PMV, _NC, _CSGa, _CPG, _CSGNa, _CN, _AMVU, _SG, _RGIe, _SRL, _SW, _ATE, _ATLMD, _TEE, _AREE, _ARN, _RGLDE, _LDC, _NT, _ID, _TEM],
+    [0, () => Endpoint$, 0, 0, 0, 0, 0, 1, 0, 0, 4, 0, [() => PendingModifiedValues$, 0], () => NotificationConfiguration$, [() => CacheSecurityGroupMembershipList, 0], [() => CacheParameterGroupStatus$, 0], 0, [() => CacheNodeList, 0], 2, () => SecurityGroupMembershipList, 0, 1, 0, 2, 4, 2, 2, 0, 2, [() => LogDeliveryConfigurationList, 0], 0, 0, 0]
+];
+var CacheClusterMessage$ = [3, n0, _CCM,
+    0,
+    [_M, _CCa],
+    [0, [() => CacheClusterList, 0]]
+];
+var CacheEngineVersion$ = [3, n0, _CEV,
+    0,
+    [_E, _EV, _CPGF, _CED, _CEVD],
+    [0, 0, 0, 0, 0]
+];
+var CacheEngineVersionMessage$ = [3, n0, _CEVM,
+    0,
+    [_M, _CEVa],
+    [0, [() => CacheEngineVersionList, 0]]
+];
+var CacheNode$ = [3, n0, _CNa,
+    0,
+    [_CNI, _CNS, _CNCT, _En, _PGS, _SCNI, _CAZ, _COA],
+    [0, 0, 4, () => Endpoint$, 0, 0, 0, 0]
+];
+var CacheNodeTypeSpecificParameter$ = [3, n0, _CNTSP,
+    0,
+    [_PN, _D, _S, _DT, _AV, _IM, _MEV, _CNTSV, _CT],
+    [0, 0, 0, 0, 0, 2, 0, [() => CacheNodeTypeSpecificValueList, 0], 0]
+];
+var CacheNodeTypeSpecificValue$ = [3, n0, _CNTSVa,
+    0,
+    [_CNT, _V],
+    [0, 0]
+];
+var CacheNodeUpdateStatus$ = [3, n0, _CNUS,
+    0,
+    [_CNI, _NUS, _NDD, _NUSD, _NUED, _NUIB, _NUID, _NUSMD],
+    [0, 0, 4, 4, 4, 0, 4, 4]
+];
+var CacheParameterGroup$ = [3, n0, _CPG,
+    0,
+    [_CPGN, _CPGF, _D, _IG, _ARN],
+    [0, 0, 0, 2, 0]
+];
+var CacheParameterGroupDetails$ = [3, n0, _CPGD,
+    0,
+    [_M, _Pa, _CNTSPa],
+    [0, [() => ParametersList, 0], [() => CacheNodeTypeSpecificParametersList, 0]]
+];
+var CacheParameterGroupNameMessage$ = [3, n0, _CPGNM,
+    0,
+    [_CPGN],
+    [0]
+];
+var CacheParameterGroupsMessage$ = [3, n0, _CPGM,
+    0,
+    [_M, _CPGa],
+    [0, [() => CacheParameterGroupList, 0]]
+];
+var CacheParameterGroupStatus$ = [3, n0, _CPGS,
+    0,
+    [_CPGN, _PAS, _CNITR],
+    [0, 0, [() => CacheNodeIdsList, 0]]
+];
+var CacheSecurityGroup$ = [3, n0, _CSG,
+    0,
+    [_OI, _CSGN, _D, _ECSG, _ARN],
+    [0, 0, 0, [() => EC2SecurityGroupList, 0], 0]
+];
+var CacheSecurityGroupMembership$ = [3, n0, _CSGM,
+    0,
+    [_CSGN, _St],
+    [0, 0]
+];
+var CacheSecurityGroupMessage$ = [3, n0, _CSGMa,
+    0,
+    [_M, _CSGa],
+    [0, [() => CacheSecurityGroups, 0]]
+];
+var CacheSubnetGroup$ = [3, n0, _CSGac,
+    0,
+    [_CSGNa, _CSGD, _VI, _Su, _ARN, _SNT],
+    [0, 0, 0, [() => SubnetList, 0], 0, 64 | 0]
+];
+var CacheSubnetGroupMessage$ = [3, n0, _CSGMac,
+    0,
+    [_M, _CSGach],
+    [0, [() => CacheSubnetGroups, 0]]
+];
+var CacheUsageLimits$ = [3, n0, _CUL,
+    0,
+    [_DS, _ECPUPS],
+    [() => DataStorage$, () => ECPUPerSecond$]
+];
+var CloudWatchLogsDestinationDetails$ = [3, n0, _CWLDD,
+    0,
+    [_LG],
+    [0]
+];
+var CompleteMigrationMessage$ = [3, n0, _CMM,
+    0,
+    [_RGIe, _F],
+    [0, 2], 1
+];
+var CompleteMigrationResponse$ = [3, n0, _CMR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var ConfigureShard$ = [3, n0, _CS,
+    0,
+    [_NGI, _NRC, _PAZr, _POAr],
+    [0, 1, [() => PreferredAvailabilityZoneList, 0], [() => PreferredOutpostArnList, 0]], 2
+];
+var CopyServerlessCacheSnapshotRequest$ = [3, n0, _CSCSR,
+    0,
+    [_SSCSN, _TSCSN, _KKI, _T],
+    [0, 0, 0, [() => TagList, 0]], 2
+];
+var CopyServerlessCacheSnapshotResponse$ = [3, n0, _CSCSRo,
+    0,
+    [_SCS],
+    [() => ServerlessCacheSnapshot$]
+];
+var CopySnapshotMessage$ = [3, n0, _CSM,
+    0,
+    [_SSN, _TSN, _TB, _KKI, _T],
+    [0, 0, 0, 0, [() => TagList, 0]], 2
+];
+var CopySnapshotResult$ = [3, n0, _CSR,
+    0,
+    [_Sn],
+    [[() => Snapshot$, 0]]
+];
+var CreateCacheClusterMessage$ = [3, n0, _CCCM,
+    0,
+    [_CCIa, _RGIe, _AZM, _PAZ, _PAZr, _NCN, _CNT, _E, _EV, _CPGN, _CSGNa, _CSGNac, _SGI, _T, _SA, _SN, _PMW, _Po, _NTA, _AMVU, _SRL, _SW, _AT, _OM, _POA, _POAr, _LDC, _TEE, _NT, _ID],
+    [0, 0, 0, 0, [() => PreferredAvailabilityZoneList, 0], 1, 0, 0, 0, 0, 0, [() => CacheSecurityGroupNameList, 0], [() => SecurityGroupIdsList, 0], [() => TagList, 0], [() => SnapshotArnsList, 0], 0, 0, 1, 0, 2, 1, 0, 0, 0, 0, [() => PreferredOutpostArnList, 0], [() => LogDeliveryConfigurationRequestList, 0], 2, 0, 0], 1
+];
+var CreateCacheClusterResult$ = [3, n0, _CCCR,
+    0,
+    [_CC],
+    [[() => CacheCluster$, 0]]
+];
+var CreateCacheParameterGroupMessage$ = [3, n0, _CCPGM,
+    0,
+    [_CPGN, _CPGF, _D, _T],
+    [0, 0, 0, [() => TagList, 0]], 3
+];
+var CreateCacheParameterGroupResult$ = [3, n0, _CCPGR,
+    0,
+    [_CPG],
+    [() => CacheParameterGroup$]
+];
+var CreateCacheSecurityGroupMessage$ = [3, n0, _CCSGM,
+    0,
+    [_CSGN, _D, _T],
+    [0, 0, [() => TagList, 0]], 2
+];
+var CreateCacheSecurityGroupResult$ = [3, n0, _CCSGR,
+    0,
+    [_CSG],
+    [[() => CacheSecurityGroup$, 0]]
+];
+var CreateCacheSubnetGroupMessage$ = [3, n0, _CCSGMr,
+    0,
+    [_CSGNa, _CSGD, _SI, _T],
+    [0, 0, [() => SubnetIdentifierList, 0], [() => TagList, 0]], 3
+];
+var CreateCacheSubnetGroupResult$ = [3, n0, _CCSGRr,
+    0,
+    [_CSGac],
+    [[() => CacheSubnetGroup$, 0]]
+];
+var CreateGlobalReplicationGroupMessage$ = [3, n0, _CGRGM,
+    0,
+    [_GRGIS, _PRGI, _GRGD],
+    [0, 0, 0], 2
+];
+var CreateGlobalReplicationGroupResult$ = [3, n0, _CGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var CreateReplicationGroupMessage$ = [3, n0, _CRGM,
+    0,
+    [_RGIe, _RGD, _GRGI, _PCI, _AFE, _MAZE, _NCC, _PCCAZ, _NNG, _RPNG, _NGC, _CNT, _E, _EV, _CPGN, _CSGNa, _CSGNac, _SGI, _T, _SA, _SN, _PMW, _Po, _NTA, _AMVU, _SRL, _SW, _AT, _TEE, _AREE, _KKI, _UGI, _LDC, _DTE, _NT, _ID, _TEM, _CM, _SCSN, _Du],
+    [0, 0, 0, 0, 2, 2, 1, [() => AvailabilityZonesList, 0], 1, 1, [() => NodeGroupConfigurationList, 0], 0, 0, 0, 0, 0, [() => CacheSecurityGroupNameList, 0], [() => SecurityGroupIdsList, 0], [() => TagList, 0], [() => SnapshotArnsList, 0], 0, 0, 1, 0, 2, 1, 0, 0, 2, 2, 0, 64 | 0, [() => LogDeliveryConfigurationRequestList, 0], 2, 0, 0, 0, 0, 0, 0], 2
+];
+var CreateReplicationGroupResult$ = [3, n0, _CRGR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var CreateServerlessCacheRequest$ = [3, n0, _CSCR,
+    0,
+    [_SCN, _E, _D, _MEVa, _CUL, _KKI, _SGI, _SATR, _T, _UGIs, _SI, _SRL, _DST, _NT],
+    [0, 0, 0, 0, () => CacheUsageLimits$, 0, [() => SecurityGroupIdsList, 0], [() => SnapshotArnsList, 0], [() => TagList, 0], 0, [() => SubnetIdsList, 0], 1, 0, 0], 2
+];
+var CreateServerlessCacheResponse$ = [3, n0, _CSCRr,
+    0,
+    [_SC],
+    [[() => ServerlessCache$, 0]]
+];
+var CreateServerlessCacheSnapshotRequest$ = [3, n0, _CSCSRr,
+    0,
+    [_SCSN, _SCN, _KKI, _T],
+    [0, 0, 0, [() => TagList, 0]], 2
+];
+var CreateServerlessCacheSnapshotResponse$ = [3, n0, _CSCSRre,
+    0,
+    [_SCS],
+    [() => ServerlessCacheSnapshot$]
+];
+var CreateSnapshotMessage$ = [3, n0, _CSMr,
+    0,
+    [_SN, _RGIe, _CCIa, _KKI, _T],
+    [0, 0, 0, 0, [() => TagList, 0]], 1
+];
+var CreateSnapshotResult$ = [3, n0, _CSRr,
+    0,
+    [_Sn],
+    [[() => Snapshot$, 0]]
+];
+var CreateUserGroupMessage$ = [3, n0, _CUGM,
+    0,
+    [_UGIs, _E, _UI, _T],
+    [0, 0, 64 | 0, [() => TagList, 0]], 2
+];
+var CreateUserMessage$ = [3, n0, _CUM,
+    0,
+    [_UIs, _UN, _E, _AS, _P, _NPR, _T, _AM],
+    [0, 0, 0, 0, 64 | 0, 2, [() => TagList, 0], () => AuthenticationMode$], 4
+];
+var CustomerNodeEndpoint$ = [3, n0, _CNE,
+    0,
+    [_Ad, _Po],
+    [0, 1]
+];
+var DataStorage$ = [3, n0, _DS,
+    0,
+    [_U, _Ma, _Mi],
+    [0, 1, 1], 1
+];
+var DecreaseNodeGroupsInGlobalReplicationGroupMessage$ = [3, n0, _DNGIGRGM,
+    0,
+    [_GRGI, _NGCo, _AI, _GNGTR, _GNGTRl],
+    [0, 1, 2, [() => GlobalNodeGroupIdList, 0], [() => GlobalNodeGroupIdList, 0]], 3
+];
+var DecreaseNodeGroupsInGlobalReplicationGroupResult$ = [3, n0, _DNGIGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var DecreaseReplicaCountMessage$ = [3, n0, _DRCM,
+    0,
+    [_RGIe, _AI, _NRC, _RC, _RTR],
+    [0, 2, 1, [() => ReplicaConfigurationList, 0], 64 | 0], 2
+];
+var DecreaseReplicaCountResult$ = [3, n0, _DRCR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var DeleteCacheClusterMessage$ = [3, n0, _DCCM,
+    0,
+    [_CCIa, _FSI],
+    [0, 0], 1
+];
+var DeleteCacheClusterResult$ = [3, n0, _DCCR,
+    0,
+    [_CC],
+    [[() => CacheCluster$, 0]]
+];
+var DeleteCacheParameterGroupMessage$ = [3, n0, _DCPGM,
+    0,
+    [_CPGN],
+    [0], 1
+];
+var DeleteCacheSecurityGroupMessage$ = [3, n0, _DCSGM,
+    0,
+    [_CSGN],
+    [0], 1
+];
+var DeleteCacheSubnetGroupMessage$ = [3, n0, _DCSGMe,
+    0,
+    [_CSGNa],
+    [0], 1
+];
+var DeleteGlobalReplicationGroupMessage$ = [3, n0, _DGRGM,
+    0,
+    [_GRGI, _RPRG],
+    [0, 2], 2
+];
+var DeleteGlobalReplicationGroupResult$ = [3, n0, _DGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var DeleteReplicationGroupMessage$ = [3, n0, _DRGM,
+    0,
+    [_RGIe, _RPC, _FSI],
+    [0, 2, 0], 1
+];
+var DeleteReplicationGroupResult$ = [3, n0, _DRGR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var DeleteServerlessCacheRequest$ = [3, n0, _DSCR,
+    0,
+    [_SCN, _FSN],
+    [0, 0], 1
+];
+var DeleteServerlessCacheResponse$ = [3, n0, _DSCRe,
+    0,
+    [_SC],
+    [[() => ServerlessCache$, 0]]
+];
+var DeleteServerlessCacheSnapshotRequest$ = [3, n0, _DSCSR,
+    0,
+    [_SCSN],
+    [0], 1
+];
+var DeleteServerlessCacheSnapshotResponse$ = [3, n0, _DSCSRe,
+    0,
+    [_SCS],
+    [() => ServerlessCacheSnapshot$]
+];
+var DeleteSnapshotMessage$ = [3, n0, _DSM,
+    0,
+    [_SN],
+    [0], 1
+];
+var DeleteSnapshotResult$ = [3, n0, _DSR,
+    0,
+    [_Sn],
+    [[() => Snapshot$, 0]]
+];
+var DeleteUserGroupMessage$ = [3, n0, _DUGM,
+    0,
+    [_UGIs],
+    [0], 1
+];
+var DeleteUserMessage$ = [3, n0, _DUM,
+    0,
+    [_UIs],
+    [0], 1
+];
+var DescribeCacheClustersMessage$ = [3, n0, _DCCMe,
+    0,
+    [_CCIa, _MR, _M, _SCNIh, _SCCNIRG],
+    [0, 1, 0, 2, 2]
+];
+var DescribeCacheEngineVersionsMessage$ = [3, n0, _DCEVM,
+    0,
+    [_E, _EV, _CPGF, _MR, _M, _DO],
+    [0, 0, 0, 1, 0, 2]
+];
+var DescribeCacheParameterGroupsMessage$ = [3, n0, _DCPGMe,
+    0,
+    [_CPGN, _MR, _M],
+    [0, 1, 0]
+];
+var DescribeCacheParametersMessage$ = [3, n0, _DCPM,
+    0,
+    [_CPGN, _S, _MR, _M],
+    [0, 0, 1, 0], 1
+];
+var DescribeCacheSecurityGroupsMessage$ = [3, n0, _DCSGMes,
+    0,
+    [_CSGN, _MR, _M],
+    [0, 1, 0]
+];
+var DescribeCacheSubnetGroupsMessage$ = [3, n0, _DCSGMesc,
+    0,
+    [_CSGNa, _MR, _M],
+    [0, 1, 0]
+];
+var DescribeEngineDefaultParametersMessage$ = [3, n0, _DEDPM,
+    0,
+    [_CPGF, _MR, _M],
+    [0, 1, 0], 1
+];
+var DescribeEngineDefaultParametersResult$ = [3, n0, _DEDPR,
+    0,
+    [_ED],
+    [[() => EngineDefaults$, 0]]
+];
+var DescribeEventsMessage$ = [3, n0, _DEM,
+    0,
+    [_SIo, _ST, _STt, _ET, _Dur, _MR, _M],
+    [0, 0, 4, 4, 1, 1, 0]
+];
+var DescribeGlobalReplicationGroupsMessage$ = [3, n0, _DGRGMe,
+    0,
+    [_GRGI, _MR, _M, _SMI],
+    [0, 1, 0, 2]
+];
+var DescribeGlobalReplicationGroupsResult$ = [3, n0, _DGRGRe,
+    0,
+    [_M, _GRGl],
+    [0, [() => GlobalReplicationGroupList, 0]]
+];
+var DescribeReplicationGroupsMessage$ = [3, n0, _DRGMe,
+    0,
+    [_RGIe, _MR, _M],
+    [0, 1, 0]
+];
+var DescribeReservedCacheNodesMessage$ = [3, n0, _DRCNM,
+    0,
+    [_RCNI, _RCNOI, _CNT, _Dur, _PD, _OT, _MR, _M],
+    [0, 0, 0, 0, 0, 0, 1, 0]
+];
+var DescribeReservedCacheNodesOfferingsMessage$ = [3, n0, _DRCNOM,
+    0,
+    [_RCNOI, _CNT, _Dur, _PD, _OT, _MR, _M],
+    [0, 0, 0, 0, 0, 1, 0]
+];
+var DescribeServerlessCacheSnapshotsRequest$ = [3, n0, _DSCSRes,
+    0,
+    [_SCN, _SCSN, _STn, _NTe, _MRa],
+    [0, 0, 0, 0, 1]
+];
+var DescribeServerlessCacheSnapshotsResponse$ = [3, n0, _DSCSResc,
+    0,
+    [_NTe, _SCSe],
+    [0, [() => ServerlessCacheSnapshotList, 0]]
+];
+var DescribeServerlessCachesRequest$ = [3, n0, _DSCRes,
+    0,
+    [_SCN, _MRa, _NTe],
+    [0, 1, 0]
+];
+var DescribeServerlessCachesResponse$ = [3, n0, _DSCResc,
+    0,
+    [_NTe, _SCe],
+    [0, [() => ServerlessCacheList, 0]]
+];
+var DescribeServiceUpdatesMessage$ = [3, n0, _DSUM,
+    0,
+    [_SUN, _SUS, _MR, _M],
+    [0, 64 | 0, 1, 0]
+];
+var DescribeSnapshotsListMessage$ = [3, n0, _DSLM,
+    0,
+    [_M, _Sna],
+    [0, [() => SnapshotList, 0]]
+];
+var DescribeSnapshotsMessage$ = [3, n0, _DSMe,
+    0,
+    [_RGIe, _CCIa, _SN, _SS, _M, _MR, _SNGC],
+    [0, 0, 0, 0, 0, 1, 2]
+];
+var DescribeUpdateActionsMessage$ = [3, n0, _DUAM,
+    0,
+    [_SUN, _RGI, _CCI, _E, _SUS, _SUTR, _UAS, _SNLUS, _MR, _M],
+    [0, 64 | 0, 64 | 0, 0, 64 | 0, () => TimeRangeFilter$, 64 | 0, 2, 1, 0]
+];
+var DescribeUserGroupsMessage$ = [3, n0, _DUGMe,
+    0,
+    [_UGIs, _MR, _M],
+    [0, 1, 0]
+];
+var DescribeUserGroupsResult$ = [3, n0, _DUGR,
+    0,
+    [_UG, _M],
+    [() => UserGroupList, 0]
+];
+var DescribeUsersMessage$ = [3, n0, _DUMe,
+    0,
+    [_E, _UIs, _Fi, _MR, _M],
+    [0, 0, () => FilterList, 1, 0]
+];
+var DescribeUsersResult$ = [3, n0, _DURe,
+    0,
+    [_Us, _M],
+    [() => UserList, 0]
+];
+var DestinationDetails$ = [3, n0, _DD,
+    0,
+    [_CWLD, _KFD],
+    [() => CloudWatchLogsDestinationDetails$, () => KinesisFirehoseDestinationDetails$]
+];
+var DisassociateGlobalReplicationGroupMessage$ = [3, n0, _DGRGMi,
+    0,
+    [_GRGI, _RGIe, _RGR],
+    [0, 0, 0], 3
+];
+var DisassociateGlobalReplicationGroupResult$ = [3, n0, _DGRGRi,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var EC2SecurityGroup$ = [3, n0, _ECSGe,
+    0,
+    [_St, _ECSGN, _ECSGOI],
+    [0, 0, 0]
+];
+var ECPUPerSecond$ = [3, n0, _ECPUPS,
+    0,
+    [_Ma, _Mi],
+    [1, 1]
+];
+var Endpoint$ = [3, n0, _En,
+    0,
+    [_Ad, _Po],
+    [0, 1]
+];
+var EngineDefaults$ = [3, n0, _ED,
+    0,
+    [_CPGF, _M, _Pa, _CNTSPa],
+    [0, 0, [() => ParametersList, 0], [() => CacheNodeTypeSpecificParametersList, 0]]
+];
+var Event$ = [3, n0, _Ev,
+    0,
+    [_SIo, _ST, _Me, _Da],
+    [0, 0, 0, 4]
+];
+var EventsMessage$ = [3, n0, _EM,
+    0,
+    [_M, _Eve],
+    [0, [() => EventList, 0]]
+];
+var ExportServerlessCacheSnapshotRequest$ = [3, n0, _ESCSR,
+    0,
+    [_SCSN, _SBN],
+    [0, 0], 2
+];
+var ExportServerlessCacheSnapshotResponse$ = [3, n0, _ESCSRx,
+    0,
+    [_SCS],
+    [() => ServerlessCacheSnapshot$]
+];
+var FailoverGlobalReplicationGroupMessage$ = [3, n0, _FGRGM,
+    0,
+    [_GRGI, _PR, _PRGI],
+    [0, 0, 0], 3
+];
+var FailoverGlobalReplicationGroupResult$ = [3, n0, _FGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var Filter$ = [3, n0, _Fil,
+    0,
+    [_N, _Va],
+    [0, 64 | 0], 2
+];
+var GlobalNodeGroup$ = [3, n0, _GNG,
+    0,
+    [_GNGI, _Sl],
+    [0, 0]
+];
+var GlobalReplicationGroup$ = [3, n0, _GRG,
+    0,
+    [_GRGI, _GRGD, _St, _CNT, _E, _EV, _Mem, _CEl, _GNGl, _ATE, _TEE, _AREE, _ARN],
+    [0, 0, 0, 0, 0, 0, [() => GlobalReplicationGroupMemberList, 0], 2, [() => GlobalNodeGroupList, 0], 2, 2, 2, 0]
+];
+var GlobalReplicationGroupInfo$ = [3, n0, _GRGIl,
+    0,
+    [_GRGI, _GRGMR],
+    [0, 0]
+];
+var GlobalReplicationGroupMember$ = [3, n0, _GRGM,
+    0,
+    [_RGIe, _RGR, _R, _AF, _St],
+    [0, 0, 0, 0, 0]
+];
+var IncreaseNodeGroupsInGlobalReplicationGroupMessage$ = [3, n0, _INGIGRGM,
+    0,
+    [_GRGI, _NGCo, _AI, _RCe],
+    [0, 1, 2, [() => RegionalConfigurationList, 0]], 3
+];
+var IncreaseNodeGroupsInGlobalReplicationGroupResult$ = [3, n0, _INGIGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var IncreaseReplicaCountMessage$ = [3, n0, _IRCM,
+    0,
+    [_RGIe, _AI, _NRC, _RC],
+    [0, 2, 1, [() => ReplicaConfigurationList, 0]], 2
+];
+var IncreaseReplicaCountResult$ = [3, n0, _IRCR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var KinesisFirehoseDestinationDetails$ = [3, n0, _KFDD,
+    0,
+    [_DSe],
+    [0]
+];
+var ListAllowedNodeTypeModificationsMessage$ = [3, n0, _LANTMM,
+    0,
+    [_CCIa, _RGIe],
+    [0, 0]
+];
+var ListTagsForResourceMessage$ = [3, n0, _LTFRM,
+    0,
+    [_RN],
+    [0], 1
+];
+var LogDeliveryConfiguration$ = [3, n0, _LDCo,
+    0,
+    [_LT, _DTe, _DD, _LF, _St, _Me],
+    [0, 0, () => DestinationDetails$, 0, 0, 0]
+];
+var LogDeliveryConfigurationRequest$ = [3, n0, _LDCR,
+    0,
+    [_LT, _DTe, _DD, _LF, _Ena],
+    [0, 0, () => DestinationDetails$, 0, 2]
+];
+var ModifyCacheClusterMessage$ = [3, n0, _MCCM,
+    0,
+    [_CCIa, _NCN, _CNITRa, _AZM, _NAZ, _CSGNac, _SGI, _PMW, _NTA, _CPGN, _NTS, _AI, _E, _EV, _AMVU, _SRL, _SW, _CNT, _AT, _ATUS, _LDC, _ID, _SCc],
+    [0, 1, [() => CacheNodeIdsList, 0], 0, [() => PreferredAvailabilityZoneList, 0], [() => CacheSecurityGroupNameList, 0], [() => SecurityGroupIdsList, 0], 0, 0, 0, 0, 2, 0, 0, 2, 1, 0, 0, 0, 0, [() => LogDeliveryConfigurationRequestList, 0], 0, () => ScaleConfig$], 1
+];
+var ModifyCacheClusterResult$ = [3, n0, _MCCR,
+    0,
+    [_CC],
+    [[() => CacheCluster$, 0]]
+];
+var ModifyCacheParameterGroupMessage$ = [3, n0, _MCPGM,
+    0,
+    [_CPGN, _PNV],
+    [0, [() => ParameterNameValueList, 0]], 2
+];
+var ModifyCacheSubnetGroupMessage$ = [3, n0, _MCSGM,
+    0,
+    [_CSGNa, _CSGD, _SI],
+    [0, 0, [() => SubnetIdentifierList, 0]], 1
+];
+var ModifyCacheSubnetGroupResult$ = [3, n0, _MCSGR,
+    0,
+    [_CSGac],
+    [[() => CacheSubnetGroup$, 0]]
+];
+var ModifyGlobalReplicationGroupMessage$ = [3, n0, _MGRGM,
+    0,
+    [_GRGI, _AI, _CNT, _E, _EV, _CPGN, _GRGD, _AFE],
+    [0, 2, 0, 0, 0, 0, 0, 2], 2
+];
+var ModifyGlobalReplicationGroupResult$ = [3, n0, _MGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var ModifyReplicationGroupMessage$ = [3, n0, _MRGM,
+    0,
+    [_RGIe, _RGD, _PCI, _SCI, _AFE, _MAZE, _NGI, _CSGNac, _SGI, _PMW, _NTA, _CPGN, _NTS, _AI, _E, _EV, _AMVU, _SRL, _SW, _CNT, _AT, _ATUS, _UGITA, _UGITR, _RUG, _LDC, _ID, _TEE, _TEM, _CM, _Du],
+    [0, 0, 0, 0, 2, 2, 0, [() => CacheSecurityGroupNameList, 0], [() => SecurityGroupIdsList, 0], 0, 0, 0, 0, 2, 0, 0, 2, 1, 0, 0, 0, 0, 64 | 0, 64 | 0, 2, [() => LogDeliveryConfigurationRequestList, 0], 0, 2, 0, 0, 0], 1
+];
+var ModifyReplicationGroupResult$ = [3, n0, _MRGR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var ModifyReplicationGroupShardConfigurationMessage$ = [3, n0, _MRGSCM,
+    0,
+    [_RGIe, _NGCo, _AI, _RCes, _NGTR, _NGTRo],
+    [0, 1, 2, [() => ReshardingConfigurationList, 0], [() => NodeGroupsToRemoveList, 0], [() => NodeGroupsToRetainList, 0]], 3
+];
+var ModifyReplicationGroupShardConfigurationResult$ = [3, n0, _MRGSCR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var ModifyServerlessCacheRequest$ = [3, n0, _MSCR,
+    0,
+    [_SCN, _D, _CUL, _RUGe, _UGIs, _SGI, _SRL, _DST, _E, _MEVa],
+    [0, 0, () => CacheUsageLimits$, 2, 0, [() => SecurityGroupIdsList, 0], 1, 0, 0, 0], 1
+];
+var ModifyServerlessCacheResponse$ = [3, n0, _MSCRo,
+    0,
+    [_SC],
+    [[() => ServerlessCache$, 0]]
+];
+var ModifyUserGroupMessage$ = [3, n0, _MUGM,
+    0,
+    [_UGIs, _UITA, _UITR, _E],
+    [0, 64 | 0, 64 | 0, 0], 1
+];
+var ModifyUserMessage$ = [3, n0, _MUM,
+    0,
+    [_UIs, _AS, _AAS, _P, _NPR, _AM, _E],
+    [0, 0, 0, 64 | 0, 2, () => AuthenticationMode$, 0], 1
+];
+var NodeGroup$ = [3, n0, _NG,
+    0,
+    [_NGI, _St, _PE, _RE, _Sl, _NGM],
+    [0, 0, () => Endpoint$, () => Endpoint$, 0, [() => NodeGroupMemberList, 0]]
+];
+var NodeGroupConfiguration$ = [3, n0, _NGC,
+    0,
+    [_NGI, _Sl, _RCep, _PAZri, _RAZ, _POAri, _ROA],
+    [0, 0, 1, 0, [() => AvailabilityZonesList, 0], 0, [() => OutpostArnsList, 0]]
+];
+var NodeGroupMember$ = [3, n0, _NGMo,
+    0,
+    [_CCIa, _CNI, _REe, _PAZ, _POA, _CR],
+    [0, 0, () => Endpoint$, 0, 0, 0]
+];
+var NodeGroupMemberUpdateStatus$ = [3, n0, _NGMUS,
+    0,
+    [_CCIa, _CNI, _NUS, _NDD, _NUSD, _NUED, _NUIB, _NUID, _NUSMD],
+    [0, 0, 0, 4, 4, 4, 0, 4, 4]
+];
+var NodeGroupUpdateStatus$ = [3, n0, _NGUS,
+    0,
+    [_NGI, _NGMUS],
+    [0, [() => NodeGroupMemberUpdateStatusList, 0]]
+];
+var NodeSnapshot$ = [3, n0, _NS,
+    0,
+    [_CCIa, _NGI, _CNI, _NGC, _CSa, _CNCT, _SCT],
+    [0, 0, 0, [() => NodeGroupConfiguration$, 0], 0, 4, 4]
+];
+var NotificationConfiguration$ = [3, n0, _NC,
+    0,
+    [_TA, _TS],
+    [0, 0]
+];
+var Parameter$ = [3, n0, _Par,
+    0,
+    [_PN, _PV, _D, _S, _DT, _AV, _IM, _MEV, _CT],
+    [0, 0, 0, 0, 0, 0, 2, 0, 0]
+];
+var ParameterNameValue$ = [3, n0, _PNVa,
+    0,
+    [_PN, _PV],
+    [0, 0]
+];
+var PendingLogDeliveryConfiguration$ = [3, n0, _PLDC,
+    0,
+    [_LT, _DTe, _DD, _LF],
+    [0, 0, () => DestinationDetails$, 0]
+];
+var PendingModifiedValues$ = [3, n0, _PMV,
+    0,
+    [_NCN, _CNITRa, _EV, _CNT, _ATS, _LDC, _TEE, _TEM, _SCc],
+    [1, [() => CacheNodeIdsList, 0], 0, 0, 0, () => PendingLogDeliveryConfigurationList, 2, 0, () => ScaleConfig$]
+];
+var ProcessedUpdateAction$ = [3, n0, _PUA,
+    0,
+    [_RGIe, _CCIa, _SUN, _UAS],
+    [0, 0, 0, 0]
+];
+var PurchaseReservedCacheNodesOfferingMessage$ = [3, n0, _PRCNOM,
+    0,
+    [_RCNOI, _RCNI, _CNC, _T],
+    [0, 0, 1, [() => TagList, 0]], 1
+];
+var PurchaseReservedCacheNodesOfferingResult$ = [3, n0, _PRCNOR,
+    0,
+    [_RCN],
+    [[() => ReservedCacheNode$, 0]]
+];
+var RebalanceSlotsInGlobalReplicationGroupMessage$ = [3, n0, _RSIGRGM,
+    0,
+    [_GRGI, _AI],
+    [0, 2], 2
+];
+var RebalanceSlotsInGlobalReplicationGroupResult$ = [3, n0, _RSIGRGR,
+    0,
+    [_GRG],
+    [[() => GlobalReplicationGroup$, 0]]
+];
+var RebootCacheClusterMessage$ = [3, n0, _RCCM,
+    0,
+    [_CCIa, _CNITR],
+    [0, [() => CacheNodeIdsList, 0]], 2
+];
+var RebootCacheClusterResult$ = [3, n0, _RCCR,
+    0,
+    [_CC],
+    [[() => CacheCluster$, 0]]
+];
+var RecurringCharge$ = [3, n0, _RCec,
+    0,
+    [_RCA, _RCF],
+    [1, 0]
+];
+var RegionalConfiguration$ = [3, n0, _RCeg,
+    0,
+    [_RGIe, _RGR, _RCes],
+    [0, 0, [() => ReshardingConfigurationList, 0]], 3
+];
+var RemoveTagsFromResourceMessage$ = [3, n0, _RTFRM,
+    0,
+    [_RN, _TK],
+    [0, 64 | 0], 2
+];
+var ReplicationGroup$ = [3, n0, _RG,
+    0,
+    [_RGIe, _D, _GRGIl, _St, _PMV, _MC, _NGo, _SCI, _AF, _MAZ, _CE, _SRL, _SW, _CEl, _CNT, _ATE, _ATLMD, _TEE, _AREE, _MCOA, _KKI, _SET, _ARN, _UGI, _LDC, _RGCT, _DTa, _AMVU, _NT, _ID, _TEM, _CM, _E, _Du, _EDf],
+    [0, 0, () => GlobalReplicationGroupInfo$, 0, () => ReplicationGroupPendingModifiedValues$, [() => ClusterIdList, 0], [() => NodeGroupList, 0], 0, 0, 0, () => Endpoint$, 1, 0, 2, 0, 2, 4, 2, 2, [() => ReplicationGroupOutpostArnList, 0], 0, 0, 0, 64 | 0, [() => LogDeliveryConfigurationList, 0], 4, 0, 2, 0, 0, 0, 0, 0, 0, 0]
+];
+var ReplicationGroupMessage$ = [3, n0, _RGM,
+    0,
+    [_M, _RGe],
+    [0, [() => ReplicationGroupList, 0]]
+];
+var ReplicationGroupPendingModifiedValues$ = [3, n0, _RGPMV,
+    0,
+    [_PCI, _AFS, _Re, _ATS, _UG, _LDC, _TEE, _TEM, _CM],
+    [0, 0, () => ReshardingStatus$, 0, () => UserGroupsUpdateStatus$, () => PendingLogDeliveryConfigurationList, 2, 0, 0]
+];
+var ReservedCacheNode$ = [3, n0, _RCN,
+    0,
+    [_RCNI, _RCNOI, _CNT, _STt, _Dur, _FP, _UP, _CNC, _PD, _OT, _Sta, _RCecu, _RARN],
+    [0, 0, 0, 4, 1, 1, 1, 1, 0, 0, 0, [() => RecurringChargeList, 0], 0]
+];
+var ReservedCacheNodeMessage$ = [3, n0, _RCNM,
+    0,
+    [_M, _RCNe],
+    [0, [() => ReservedCacheNodeList, 0]]
+];
+var ReservedCacheNodesOffering$ = [3, n0, _RCNO,
+    0,
+    [_RCNOI, _CNT, _Dur, _FP, _UP, _PD, _OT, _RCecu],
+    [0, 0, 1, 1, 1, 0, 0, [() => RecurringChargeList, 0]]
+];
+var ReservedCacheNodesOfferingMessage$ = [3, n0, _RCNOM,
+    0,
+    [_M, _RCNOe],
+    [0, [() => ReservedCacheNodesOfferingList, 0]]
+];
+var ResetCacheParameterGroupMessage$ = [3, n0, _RCPGM,
+    0,
+    [_CPGN, _RAP, _PNV],
+    [0, 2, [() => ParameterNameValueList, 0]], 1
+];
+var ReshardingConfiguration$ = [3, n0, _RCes,
+    0,
+    [_NGI, _PAZr],
+    [0, [() => AvailabilityZonesList, 0]]
+];
+var ReshardingStatus$ = [3, n0, _RS,
+    0,
+    [_SM],
+    [() => SlotMigration$]
+];
+var RevokeCacheSecurityGroupIngressMessage$ = [3, n0, _RCSGIM,
+    0,
+    [_CSGN, _ECSGN, _ECSGOI],
+    [0, 0, 0], 3
+];
+var RevokeCacheSecurityGroupIngressResult$ = [3, n0, _RCSGIR,
+    0,
+    [_CSG],
+    [[() => CacheSecurityGroup$, 0]]
+];
+var ScaleConfig$ = [3, n0, _SCc,
+    0,
+    [_SP, _SIM],
+    [1, 1]
+];
+var SecurityGroupMembership$ = [3, n0, _SGM,
+    0,
+    [_SGIe, _St],
+    [0, 0]
+];
+var ServerlessCache$ = [3, n0, _SC,
+    0,
+    [_SCN, _D, _CTr, _St, _E, _MEVa, _FEV, _CUL, _KKI, _SET, _SGI, _En, _RE, _ARN, _UGIs, _SI, _SRL, _DST, _NT],
+    [0, 0, 4, 0, 0, 0, 0, () => CacheUsageLimits$, 0, 0, [() => SecurityGroupIdsList, 0], () => Endpoint$, () => Endpoint$, 0, 0, [() => SubnetIdsList, 0], 1, 0, 0]
+];
+var ServerlessCacheConfiguration$ = [3, n0, _SCC,
+    0,
+    [_SCN, _E, _MEVa],
+    [0, 0, 0]
+];
+var ServerlessCacheSnapshot$ = [3, n0, _SCS,
+    0,
+    [_SCSN, _ARN, _KKI, _STn, _St, _CTr, _ETx, _BUFC, _SCC],
+    [0, 0, 0, 0, 0, 4, 4, 0, () => ServerlessCacheConfiguration$]
+];
+var ServiceUpdate$ = [3, n0, _SU,
+    0,
+    [_SUN, _SURD, _SUED, _SUSe, _SURABD, _SUS, _SUD, _SUT, _E, _EV, _AUARABD, _EUT],
+    [0, 4, 4, 0, 4, 0, 0, 0, 0, 0, 2, 0]
+];
+var ServiceUpdatesMessage$ = [3, n0, _SUMe,
+    0,
+    [_M, _SUe],
+    [0, [() => ServiceUpdateList, 0]]
+];
+var SlotMigration$ = [3, n0, _SM,
+    0,
+    [_PP],
+    [1]
+];
+var Snapshot$ = [3, n0, _Sn,
+    0,
+    [_SN, _RGIe, _RGD, _CCIa, _SSn, _SS, _CNT, _E, _EV, _NCN, _PAZ, _POA, _CCCT, _PMW, _TA, _Po, _CPGN, _CSGNa, _VI, _AMVU, _SRL, _SW, _NNG, _AF, _NSo, _KKI, _ARN, _DTa, _Du],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 1, 0, 0, 0, 2, 1, 0, 1, 0, [() => NodeSnapshotList, 0], 0, 0, 0, 0]
+];
+var StartMigrationMessage$ = [3, n0, _SMM,
+    0,
+    [_RGIe, _CNEL],
+    [0, () => CustomerNodeEndpointList], 2
+];
+var StartMigrationResponse$ = [3, n0, _SMR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var Subnet$ = [3, n0, _Sub,
+    0,
+    [_SIu, _SAZ, _SO, _SNT],
+    [0, () => AvailabilityZone$, () => SubnetOutpost$, 64 | 0]
+];
+var SubnetOutpost$ = [3, n0, _SO,
+    0,
+    [_SOA],
+    [0]
+];
+var Tag$ = [3, n0, _Ta,
+    0,
+    [_K, _V],
+    [0, 0]
+];
+var TagListMessage$ = [3, n0, _TLM,
+    0,
+    [_TL],
+    [[() => TagList, 0]]
+];
+var TestFailoverMessage$ = [3, n0, _TFM,
+    0,
+    [_RGIe, _NGI],
+    [0, 0], 2
+];
+var TestFailoverResult$ = [3, n0, _TFR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var TestMigrationMessage$ = [3, n0, _TMM,
+    0,
+    [_RGIe, _CNEL],
+    [0, () => CustomerNodeEndpointList], 2
+];
+var TestMigrationResponse$ = [3, n0, _TMR,
+    0,
+    [_RG],
+    [[() => ReplicationGroup$, 0]]
+];
+var TimeRangeFilter$ = [3, n0, _TRF,
+    0,
+    [_STt, _ET],
+    [4, 4]
+];
+var UnprocessedUpdateAction$ = [3, n0, _UUA,
+    0,
+    [_RGIe, _CCIa, _SUN, _ETr, _EMr],
+    [0, 0, 0, 0, 0]
+];
+var UpdateAction$ = [3, n0, _UA,
+    0,
+    [_RGIe, _CCIa, _SUN, _SURD, _SUSe, _SUS, _SURABD, _SUT, _UAAD, _UAS, _NU, _UASMD, _SMl, _NGUS, _CNUS, _EUT, _E],
+    [0, 0, 0, 4, 0, 0, 4, 0, 4, 0, 0, 4, 0, [() => NodeGroupUpdateStatusList, 0], [() => CacheNodeUpdateStatusList, 0], 0, 0]
+];
+var UpdateActionResultsMessage$ = [3, n0, _UARM,
+    0,
+    [_PUAr, _UUAn],
+    [[() => ProcessedUpdateActionList, 0], [() => UnprocessedUpdateActionList, 0]]
+];
+var UpdateActionsMessage$ = [3, n0, _UAM,
+    0,
+    [_M, _UAp],
+    [0, [() => UpdateActionList, 0]]
+];
+var User$ = [3, n0, _Use,
+    0,
+    [_UIs, _UN, _St, _E, _MEV, _AS, _UGI, _A, _ARN],
+    [0, 0, 0, 0, 0, 0, 64 | 0, () => Authentication$, 0]
+];
+var UserGroup$ = [3, n0, _UGs,
+    0,
+    [_UGIs, _St, _E, _UI, _MEV, _PCe, _RGe, _SCe, _ARN],
+    [0, 0, 0, 64 | 0, 0, () => UserGroupPendingChanges$, 64 | 0, 64 | 0, 0]
+];
+var UserGroupPendingChanges$ = [3, n0, _UGPC,
+    0,
+    [_UITR, _UITA],
+    [64 | 0, 64 | 0]
+];
+var UserGroupsUpdateStatus$ = [3, n0, _UGUS,
+    0,
+    [_UGITA, _UGITR],
+    [64 | 0, 64 | 0]
+];
+var __Unit = "unit";
+var AvailabilityZonesList = [1, n0, _AZL,
+    0, [0,
+        { [_xN]: _AZ }]
+];
+var CacheClusterList = [1, n0, _CCL,
+    0, [() => CacheCluster$,
+        { [_xN]: _CC }]
+];
+var CacheEngineVersionList = [1, n0, _CEVL,
+    0, [() => CacheEngineVersion$,
+        { [_xN]: _CEV }]
+];
+var CacheNodeIdsList = [1, n0, _CNIL,
+    0, [0,
+        { [_xN]: _CNI }]
+];
+var CacheNodeList = [1, n0, _CNL,
+    0, [() => CacheNode$,
+        { [_xN]: _CNa }]
+];
+var CacheNodeTypeSpecificParametersList = [1, n0, _CNTSPL,
+    0, [() => CacheNodeTypeSpecificParameter$,
+        { [_xN]: _CNTSP }]
+];
+var CacheNodeTypeSpecificValueList = [1, n0, _CNTSVL,
+    0, [() => CacheNodeTypeSpecificValue$,
+        { [_xN]: _CNTSVa }]
+];
+var CacheNodeUpdateStatusList = [1, n0, _CNUSL,
+    0, [() => CacheNodeUpdateStatus$,
+        { [_xN]: _CNUS }]
+];
+var CacheParameterGroupList = [1, n0, _CPGL,
+    0, [() => CacheParameterGroup$,
+        { [_xN]: _CPG }]
+];
+var CacheSecurityGroupMembershipList = [1, n0, _CSGML,
+    0, [() => CacheSecurityGroupMembership$,
+        { [_xN]: _CSG }]
+];
+var CacheSecurityGroupNameList = [1, n0, _CSGNL,
+    0, [0,
+        { [_xN]: _CSGN }]
+];
+var CacheSecurityGroups = [1, n0, _CSGa,
+    0, [() => CacheSecurityGroup$,
+        { [_xN]: _CSG }]
+];
+var CacheSubnetGroups = [1, n0, _CSGach,
+    0, [() => CacheSubnetGroup$,
+        { [_xN]: _CSGac }]
+];
+var ClusterIdList = [1, n0, _CIL,
+    0, [0,
+        { [_xN]: _CI }]
+];
+var CustomerNodeEndpointList = [1, n0, _CNEL,
+    0, () => CustomerNodeEndpoint$
+];
+var EC2SecurityGroupList = [1, n0, _ECSGL,
+    0, [() => EC2SecurityGroup$,
+        { [_xN]: _ECSGe }]
+];
+var EventList = [1, n0, _EL,
+    0, [() => Event$,
+        { [_xN]: _Ev }]
+];
+var FilterList = [1, n0, _FL,
+    0, () => Filter$
+];
+var GlobalNodeGroupIdList = [1, n0, _GNGIL,
+    0, [0,
+        { [_xN]: _GNGI }]
+];
+var GlobalNodeGroupList = [1, n0, _GNGL,
+    0, [() => GlobalNodeGroup$,
+        { [_xN]: _GNG }]
+];
+var GlobalReplicationGroupList = [1, n0, _GRGL,
+    0, [() => GlobalReplicationGroup$,
+        { [_xN]: _GRG }]
+];
+var GlobalReplicationGroupMemberList = [1, n0, _GRGML,
+    0, [() => GlobalReplicationGroupMember$,
+        { [_xN]: _GRGM }]
+];
+var LogDeliveryConfigurationList = [1, n0, _LDCL,
+    0, [() => LogDeliveryConfiguration$,
+        { [_xN]: _LDCo }]
+];
+var LogDeliveryConfigurationRequestList = [1, n0, _LDCRL,
+    0, [() => LogDeliveryConfigurationRequest$,
+        { [_xN]: _LDCR }]
+];
+var NodeGroupConfigurationList = [1, n0, _NGCL,
+    0, [() => NodeGroupConfiguration$,
+        { [_xN]: _NGC }]
+];
+var NodeGroupList = [1, n0, _NGL,
+    0, [() => NodeGroup$,
+        { [_xN]: _NG }]
+];
+var NodeGroupMemberList = [1, n0, _NGML,
+    0, [() => NodeGroupMember$,
+        { [_xN]: _NGMo }]
+];
+var NodeGroupMemberUpdateStatusList = [1, n0, _NGMUSL,
+    0, [() => NodeGroupMemberUpdateStatus$,
+        { [_xN]: _NGMUS }]
+];
+var NodeGroupsToRemoveList = [1, n0, _NGTRL,
+    0, [0,
+        { [_xN]: _NGTRod }]
+];
+var NodeGroupsToRetainList = [1, n0, _NGTRLo,
+    0, [0,
+        { [_xN]: _NGTRode }]
+];
+var NodeGroupUpdateStatusList = [1, n0, _NGUSL,
+    0, [() => NodeGroupUpdateStatus$,
+        { [_xN]: _NGUS }]
+];
+var NodeSnapshotList = [1, n0, _NSL,
+    0, [() => NodeSnapshot$,
+        { [_xN]: _NS }]
+];
+var OutpostArnsList = [1, n0, _OAL,
+    0, [0,
+        { [_xN]: _OA }]
+];
+var ParameterNameValueList = [1, n0, _PNVL,
+    0, [() => ParameterNameValue$,
+        { [_xN]: _PNVa }]
+];
+var ParametersList = [1, n0, _PL,
+    0, [() => Parameter$,
+        { [_xN]: _Par }]
+];
+var PendingLogDeliveryConfigurationList = [1, n0, _PLDCL,
+    0, () => PendingLogDeliveryConfiguration$
+];
+var PreferredAvailabilityZoneList = [1, n0, _PAZL,
+    0, [0,
+        { [_xN]: _PAZ }]
+];
+var PreferredOutpostArnList = [1, n0, _POAL,
+    0, [0,
+        { [_xN]: _POA }]
+];
+var ProcessedUpdateActionList = [1, n0, _PUAL,
+    0, [() => ProcessedUpdateAction$,
+        { [_xN]: _PUA }]
+];
+var RecurringChargeList = [1, n0, _RCL,
+    0, [() => RecurringCharge$,
+        { [_xN]: _RCec }]
+];
+var RegionalConfigurationList = [1, n0, _RCLe,
+    0, [() => RegionalConfiguration$,
+        { [_xN]: _RCeg }]
+];
+var ReplicaConfigurationList = [1, n0, _RCLep,
+    0, [() => ConfigureShard$,
+        { [_xN]: _CS }]
+];
+var ReplicationGroupList = [1, n0, _RGL,
+    0, [() => ReplicationGroup$,
+        { [_xN]: _RG }]
+];
+var ReplicationGroupOutpostArnList = [1, n0, _RGOAL,
+    0, [0,
+        { [_xN]: _RGOA }]
+];
+var ReservedCacheNodeList = [1, n0, _RCNL,
+    0, [() => ReservedCacheNode$,
+        { [_xN]: _RCN }]
+];
+var ReservedCacheNodesOfferingList = [1, n0, _RCNOL,
+    0, [() => ReservedCacheNodesOffering$,
+        { [_xN]: _RCNO }]
+];
+var ReshardingConfigurationList = [1, n0, _RCLes,
+    0, [() => ReshardingConfiguration$,
+        { [_xN]: _RCes }]
+];
+var SecurityGroupIdsList = [1, n0, _SGIL,
+    0, [0,
+        { [_xN]: _SGIe }]
+];
+var SecurityGroupMembershipList = [1, n0, _SGML,
+    0, () => SecurityGroupMembership$
+];
+var ServerlessCacheList = [1, n0, _SCL,
+    0, [() => ServerlessCache$,
+        0]
+];
+var ServerlessCacheSnapshotList = [1, n0, _SCSL,
+    0, [() => ServerlessCacheSnapshot$,
+        { [_xN]: _SCS }]
+];
+var ServiceUpdateList = [1, n0, _SUL,
+    0, [() => ServiceUpdate$,
+        { [_xN]: _SU }]
+];
+var SnapshotArnsList = [1, n0, _SAL,
+    0, [0,
+        { [_xN]: _SAn }]
+];
+var SnapshotList = [1, n0, _SL,
+    0, [() => Snapshot$,
+        { [_xN]: _Sn }]
+];
+var SubnetIdentifierList = [1, n0, _SIL,
+    0, [0,
+        { [_xN]: _SIu }]
+];
+var SubnetIdsList = [1, n0, _SILu,
+    0, [0,
+        { [_xN]: _SIub }]
+];
+var SubnetList = [1, n0, _SLu,
+    0, [() => Subnet$,
+        { [_xN]: _Sub }]
+];
+var TagList = [1, n0, _TL,
+    0, [() => Tag$,
+        { [_xN]: _Ta }]
+];
+var UnprocessedUpdateActionList = [1, n0, _UUAL,
+    0, [() => UnprocessedUpdateAction$,
+        { [_xN]: _UUA }]
+];
+var UpdateActionList = [1, n0, _UAL,
+    0, [() => UpdateAction$,
+        { [_xN]: _UA }]
+];
+var UserGroupList = [1, n0, _UGL,
+    0, () => UserGroup$
+];
+var UserList = [1, n0, _UL,
+    0, () => User$
+];
+var AddTagsToResource$ = [9, n0, _ATTR,
+    0, () => AddTagsToResourceMessage$, () => TagListMessage$
+];
+var AuthorizeCacheSecurityGroupIngress$ = [9, n0, _ACSGI,
+    0, () => AuthorizeCacheSecurityGroupIngressMessage$, () => AuthorizeCacheSecurityGroupIngressResult$
+];
+var BatchApplyUpdateAction$ = [9, n0, _BAUA,
+    0, () => BatchApplyUpdateActionMessage$, () => UpdateActionResultsMessage$
+];
+var BatchStopUpdateAction$ = [9, n0, _BSUA,
+    0, () => BatchStopUpdateActionMessage$, () => UpdateActionResultsMessage$
+];
+var CompleteMigration$ = [9, n0, _CMo,
+    0, () => CompleteMigrationMessage$, () => CompleteMigrationResponse$
+];
+var CopyServerlessCacheSnapshot$ = [9, n0, _CSCS,
+    0, () => CopyServerlessCacheSnapshotRequest$, () => CopyServerlessCacheSnapshotResponse$
+];
+var CopySnapshot$ = [9, n0, _CSo,
+    0, () => CopySnapshotMessage$, () => CopySnapshotResult$
+];
+var CreateCacheCluster$ = [9, n0, _CCC,
+    0, () => CreateCacheClusterMessage$, () => CreateCacheClusterResult$
+];
+var CreateCacheParameterGroup$ = [9, n0, _CCPG,
+    0, () => CreateCacheParameterGroupMessage$, () => CreateCacheParameterGroupResult$
+];
+var CreateCacheSecurityGroup$ = [9, n0, _CCSG,
+    0, () => CreateCacheSecurityGroupMessage$, () => CreateCacheSecurityGroupResult$
+];
+var CreateCacheSubnetGroup$ = [9, n0, _CCSGr,
+    0, () => CreateCacheSubnetGroupMessage$, () => CreateCacheSubnetGroupResult$
+];
+var CreateGlobalReplicationGroup$ = [9, n0, _CGRG,
+    0, () => CreateGlobalReplicationGroupMessage$, () => CreateGlobalReplicationGroupResult$
+];
+var CreateReplicationGroup$ = [9, n0, _CRG,
+    0, () => CreateReplicationGroupMessage$, () => CreateReplicationGroupResult$
+];
+var CreateServerlessCache$ = [9, n0, _CSC,
+    0, () => CreateServerlessCacheRequest$, () => CreateServerlessCacheResponse$
+];
+var CreateServerlessCacheSnapshot$ = [9, n0, _CSCSr,
+    0, () => CreateServerlessCacheSnapshotRequest$, () => CreateServerlessCacheSnapshotResponse$
+];
+var CreateSnapshot$ = [9, n0, _CSr,
+    0, () => CreateSnapshotMessage$, () => CreateSnapshotResult$
+];
+var CreateUser$ = [9, n0, _CU,
+    0, () => CreateUserMessage$, () => User$
+];
+var CreateUserGroup$ = [9, n0, _CUG,
+    0, () => CreateUserGroupMessage$, () => UserGroup$
+];
+var DecreaseNodeGroupsInGlobalReplicationGroup$ = [9, n0, _DNGIGRG,
+    0, () => DecreaseNodeGroupsInGlobalReplicationGroupMessage$, () => DecreaseNodeGroupsInGlobalReplicationGroupResult$
+];
+var DecreaseReplicaCount$ = [9, n0, _DRC,
+    0, () => DecreaseReplicaCountMessage$, () => DecreaseReplicaCountResult$
+];
+var DeleteCacheCluster$ = [9, n0, _DCC,
+    0, () => DeleteCacheClusterMessage$, () => DeleteCacheClusterResult$
+];
+var DeleteCacheParameterGroup$ = [9, n0, _DCPG,
+    0, () => DeleteCacheParameterGroupMessage$, () => __Unit
+];
+var DeleteCacheSecurityGroup$ = [9, n0, _DCSG,
+    0, () => DeleteCacheSecurityGroupMessage$, () => __Unit
+];
+var DeleteCacheSubnetGroup$ = [9, n0, _DCSGe,
+    0, () => DeleteCacheSubnetGroupMessage$, () => __Unit
+];
+var DeleteGlobalReplicationGroup$ = [9, n0, _DGRG,
+    0, () => DeleteGlobalReplicationGroupMessage$, () => DeleteGlobalReplicationGroupResult$
+];
+var DeleteReplicationGroup$ = [9, n0, _DRG,
+    0, () => DeleteReplicationGroupMessage$, () => DeleteReplicationGroupResult$
+];
+var DeleteServerlessCache$ = [9, n0, _DSC,
+    0, () => DeleteServerlessCacheRequest$, () => DeleteServerlessCacheResponse$
+];
+var DeleteServerlessCacheSnapshot$ = [9, n0, _DSCS,
+    0, () => DeleteServerlessCacheSnapshotRequest$, () => DeleteServerlessCacheSnapshotResponse$
+];
+var DeleteSnapshot$ = [9, n0, _DSel,
+    0, () => DeleteSnapshotMessage$, () => DeleteSnapshotResult$
+];
+var DeleteUser$ = [9, n0, _DU,
+    0, () => DeleteUserMessage$, () => User$
+];
+var DeleteUserGroup$ = [9, n0, _DUG,
+    0, () => DeleteUserGroupMessage$, () => UserGroup$
+];
+var DescribeCacheClusters$ = [9, n0, _DCCe,
+    0, () => DescribeCacheClustersMessage$, () => CacheClusterMessage$
+];
+var DescribeCacheEngineVersions$ = [9, n0, _DCEV,
+    0, () => DescribeCacheEngineVersionsMessage$, () => CacheEngineVersionMessage$
+];
+var DescribeCacheParameterGroups$ = [9, n0, _DCPGe,
+    0, () => DescribeCacheParameterGroupsMessage$, () => CacheParameterGroupsMessage$
+];
+var DescribeCacheParameters$ = [9, n0, _DCP,
+    0, () => DescribeCacheParametersMessage$, () => CacheParameterGroupDetails$
+];
+var DescribeCacheSecurityGroups$ = [9, n0, _DCSGes,
+    0, () => DescribeCacheSecurityGroupsMessage$, () => CacheSecurityGroupMessage$
+];
+var DescribeCacheSubnetGroups$ = [9, n0, _DCSGesc,
+    0, () => DescribeCacheSubnetGroupsMessage$, () => CacheSubnetGroupMessage$
+];
+var DescribeEngineDefaultParameters$ = [9, n0, _DEDP,
+    0, () => DescribeEngineDefaultParametersMessage$, () => DescribeEngineDefaultParametersResult$
+];
+var DescribeEvents$ = [9, n0, _DE,
+    0, () => DescribeEventsMessage$, () => EventsMessage$
+];
+var DescribeGlobalReplicationGroups$ = [9, n0, _DGRGe,
+    0, () => DescribeGlobalReplicationGroupsMessage$, () => DescribeGlobalReplicationGroupsResult$
+];
+var DescribeReplicationGroups$ = [9, n0, _DRGe,
+    0, () => DescribeReplicationGroupsMessage$, () => ReplicationGroupMessage$
+];
+var DescribeReservedCacheNodes$ = [9, n0, _DRCN,
+    0, () => DescribeReservedCacheNodesMessage$, () => ReservedCacheNodeMessage$
+];
+var DescribeReservedCacheNodesOfferings$ = [9, n0, _DRCNO,
+    0, () => DescribeReservedCacheNodesOfferingsMessage$, () => ReservedCacheNodesOfferingMessage$
+];
+var DescribeServerlessCaches$ = [9, n0, _DSCe,
+    0, () => DescribeServerlessCachesRequest$, () => DescribeServerlessCachesResponse$
+];
+var DescribeServerlessCacheSnapshots$ = [9, n0, _DSCSe,
+    0, () => DescribeServerlessCacheSnapshotsRequest$, () => DescribeServerlessCacheSnapshotsResponse$
+];
+var DescribeServiceUpdates$ = [9, n0, _DSU,
+    0, () => DescribeServiceUpdatesMessage$, () => ServiceUpdatesMessage$
+];
+var DescribeSnapshots$ = [9, n0, _DSes,
+    0, () => DescribeSnapshotsMessage$, () => DescribeSnapshotsListMessage$
+];
+var DescribeUpdateActions$ = [9, n0, _DUA,
+    0, () => DescribeUpdateActionsMessage$, () => UpdateActionsMessage$
+];
+var DescribeUserGroups$ = [9, n0, _DUGe,
+    0, () => DescribeUserGroupsMessage$, () => DescribeUserGroupsResult$
+];
+var DescribeUsers$ = [9, n0, _DUe,
+    0, () => DescribeUsersMessage$, () => DescribeUsersResult$
+];
+var DisassociateGlobalReplicationGroup$ = [9, n0, _DGRGi,
+    0, () => DisassociateGlobalReplicationGroupMessage$, () => DisassociateGlobalReplicationGroupResult$
+];
+var ExportServerlessCacheSnapshot$ = [9, n0, _ESCS,
+    0, () => ExportServerlessCacheSnapshotRequest$, () => ExportServerlessCacheSnapshotResponse$
+];
+var FailoverGlobalReplicationGroup$ = [9, n0, _FGRG,
+    0, () => FailoverGlobalReplicationGroupMessage$, () => FailoverGlobalReplicationGroupResult$
+];
+var IncreaseNodeGroupsInGlobalReplicationGroup$ = [9, n0, _INGIGRG,
+    0, () => IncreaseNodeGroupsInGlobalReplicationGroupMessage$, () => IncreaseNodeGroupsInGlobalReplicationGroupResult$
+];
+var IncreaseReplicaCount$ = [9, n0, _IRC,
+    0, () => IncreaseReplicaCountMessage$, () => IncreaseReplicaCountResult$
+];
+var ListAllowedNodeTypeModifications$ = [9, n0, _LANTM,
+    0, () => ListAllowedNodeTypeModificationsMessage$, () => AllowedNodeTypeModificationsMessage$
+];
+var ListTagsForResource$ = [9, n0, _LTFR,
+    0, () => ListTagsForResourceMessage$, () => TagListMessage$
+];
+var ModifyCacheCluster$ = [9, n0, _MCC,
+    0, () => ModifyCacheClusterMessage$, () => ModifyCacheClusterResult$
+];
+var ModifyCacheParameterGroup$ = [9, n0, _MCPG,
+    0, () => ModifyCacheParameterGroupMessage$, () => CacheParameterGroupNameMessage$
+];
+var ModifyCacheSubnetGroup$ = [9, n0, _MCSG,
+    0, () => ModifyCacheSubnetGroupMessage$, () => ModifyCacheSubnetGroupResult$
+];
+var ModifyGlobalReplicationGroup$ = [9, n0, _MGRG,
+    0, () => ModifyGlobalReplicationGroupMessage$, () => ModifyGlobalReplicationGroupResult$
+];
+var ModifyReplicationGroup$ = [9, n0, _MRG,
+    0, () => ModifyReplicationGroupMessage$, () => ModifyReplicationGroupResult$
+];
+var ModifyReplicationGroupShardConfiguration$ = [9, n0, _MRGSC,
+    0, () => ModifyReplicationGroupShardConfigurationMessage$, () => ModifyReplicationGroupShardConfigurationResult$
+];
+var ModifyServerlessCache$ = [9, n0, _MSC,
+    0, () => ModifyServerlessCacheRequest$, () => ModifyServerlessCacheResponse$
+];
+var ModifyUser$ = [9, n0, _MU,
+    0, () => ModifyUserMessage$, () => User$
+];
+var ModifyUserGroup$ = [9, n0, _MUG,
+    0, () => ModifyUserGroupMessage$, () => UserGroup$
+];
+var PurchaseReservedCacheNodesOffering$ = [9, n0, _PRCNO,
+    0, () => PurchaseReservedCacheNodesOfferingMessage$, () => PurchaseReservedCacheNodesOfferingResult$
+];
+var RebalanceSlotsInGlobalReplicationGroup$ = [9, n0, _RSIGRG,
+    0, () => RebalanceSlotsInGlobalReplicationGroupMessage$, () => RebalanceSlotsInGlobalReplicationGroupResult$
+];
+var RebootCacheCluster$ = [9, n0, _RCC,
+    0, () => RebootCacheClusterMessage$, () => RebootCacheClusterResult$
+];
+var RemoveTagsFromResource$ = [9, n0, _RTFR,
+    0, () => RemoveTagsFromResourceMessage$, () => TagListMessage$
+];
+var ResetCacheParameterGroup$ = [9, n0, _RCPG,
+    0, () => ResetCacheParameterGroupMessage$, () => CacheParameterGroupNameMessage$
+];
+var RevokeCacheSecurityGroupIngress$ = [9, n0, _RCSGI,
+    0, () => RevokeCacheSecurityGroupIngressMessage$, () => RevokeCacheSecurityGroupIngressResult$
+];
+var StartMigration$ = [9, n0, _SMt,
+    0, () => StartMigrationMessage$, () => StartMigrationResponse$
+];
+var TestFailover$ = [9, n0, _TF,
+    0, () => TestFailoverMessage$, () => TestFailoverResult$
+];
+var TestMigration$ = [9, n0, _TM,
+    0, () => TestMigrationMessage$, () => TestMigrationResponse$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2015-02-02",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultElastiCacheHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsQueryProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.elasticache",
+            errorTypeRegistries,
+            xmlNamespace: "http://elasticache.amazonaws.com/doc/2015-02-02/",
+            version: "2015-02-02",
+            serviceTarget: "AmazonElastiCacheV9",
+        },
+        serviceId: config?.serviceId ?? "ElastiCache",
+        sha256: config?.sha256 ?? Sha256,
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -1654,114 +5442,552 @@ const AuthTokenUpdateStrategyType = {
     SET: "SET",
 };
 
+exports.APICallRateForCustomerExceededFault = APICallRateForCustomerExceededFault;
+exports.APICallRateForCustomerExceededFault$ = APICallRateForCustomerExceededFault$;
 exports.AZMode = AZMode;
+exports.AddTagsToResource$ = AddTagsToResource$;
 exports.AddTagsToResourceCommand = AddTagsToResourceCommand;
+exports.AddTagsToResourceMessage$ = AddTagsToResourceMessage$;
+exports.AllowedNodeTypeModificationsMessage$ = AllowedNodeTypeModificationsMessage$;
 exports.AuthTokenUpdateStatus = AuthTokenUpdateStatus;
 exports.AuthTokenUpdateStrategyType = AuthTokenUpdateStrategyType;
+exports.Authentication$ = Authentication$;
+exports.AuthenticationMode$ = AuthenticationMode$;
 exports.AuthenticationType = AuthenticationType;
+exports.AuthorizationAlreadyExistsFault = AuthorizationAlreadyExistsFault;
+exports.AuthorizationAlreadyExistsFault$ = AuthorizationAlreadyExistsFault$;
+exports.AuthorizationNotFoundFault = AuthorizationNotFoundFault;
+exports.AuthorizationNotFoundFault$ = AuthorizationNotFoundFault$;
+exports.AuthorizeCacheSecurityGroupIngress$ = AuthorizeCacheSecurityGroupIngress$;
 exports.AuthorizeCacheSecurityGroupIngressCommand = AuthorizeCacheSecurityGroupIngressCommand;
+exports.AuthorizeCacheSecurityGroupIngressMessage$ = AuthorizeCacheSecurityGroupIngressMessage$;
+exports.AuthorizeCacheSecurityGroupIngressResult$ = AuthorizeCacheSecurityGroupIngressResult$;
 exports.AutomaticFailoverStatus = AutomaticFailoverStatus;
+exports.AvailabilityZone$ = AvailabilityZone$;
+exports.BatchApplyUpdateAction$ = BatchApplyUpdateAction$;
 exports.BatchApplyUpdateActionCommand = BatchApplyUpdateActionCommand;
+exports.BatchApplyUpdateActionMessage$ = BatchApplyUpdateActionMessage$;
+exports.BatchStopUpdateAction$ = BatchStopUpdateAction$;
 exports.BatchStopUpdateActionCommand = BatchStopUpdateActionCommand;
+exports.BatchStopUpdateActionMessage$ = BatchStopUpdateActionMessage$;
+exports.CacheCluster$ = CacheCluster$;
+exports.CacheClusterAlreadyExistsFault = CacheClusterAlreadyExistsFault;
+exports.CacheClusterAlreadyExistsFault$ = CacheClusterAlreadyExistsFault$;
+exports.CacheClusterMessage$ = CacheClusterMessage$;
+exports.CacheClusterNotFoundFault = CacheClusterNotFoundFault;
+exports.CacheClusterNotFoundFault$ = CacheClusterNotFoundFault$;
+exports.CacheEngineVersion$ = CacheEngineVersion$;
+exports.CacheEngineVersionMessage$ = CacheEngineVersionMessage$;
+exports.CacheNode$ = CacheNode$;
+exports.CacheNodeTypeSpecificParameter$ = CacheNodeTypeSpecificParameter$;
+exports.CacheNodeTypeSpecificValue$ = CacheNodeTypeSpecificValue$;
+exports.CacheNodeUpdateStatus$ = CacheNodeUpdateStatus$;
+exports.CacheParameterGroup$ = CacheParameterGroup$;
+exports.CacheParameterGroupAlreadyExistsFault = CacheParameterGroupAlreadyExistsFault;
+exports.CacheParameterGroupAlreadyExistsFault$ = CacheParameterGroupAlreadyExistsFault$;
+exports.CacheParameterGroupDetails$ = CacheParameterGroupDetails$;
+exports.CacheParameterGroupNameMessage$ = CacheParameterGroupNameMessage$;
+exports.CacheParameterGroupNotFoundFault = CacheParameterGroupNotFoundFault;
+exports.CacheParameterGroupNotFoundFault$ = CacheParameterGroupNotFoundFault$;
+exports.CacheParameterGroupQuotaExceededFault = CacheParameterGroupQuotaExceededFault;
+exports.CacheParameterGroupQuotaExceededFault$ = CacheParameterGroupQuotaExceededFault$;
+exports.CacheParameterGroupStatus$ = CacheParameterGroupStatus$;
+exports.CacheParameterGroupsMessage$ = CacheParameterGroupsMessage$;
+exports.CacheSecurityGroup$ = CacheSecurityGroup$;
+exports.CacheSecurityGroupAlreadyExistsFault = CacheSecurityGroupAlreadyExistsFault;
+exports.CacheSecurityGroupAlreadyExistsFault$ = CacheSecurityGroupAlreadyExistsFault$;
+exports.CacheSecurityGroupMembership$ = CacheSecurityGroupMembership$;
+exports.CacheSecurityGroupMessage$ = CacheSecurityGroupMessage$;
+exports.CacheSecurityGroupNotFoundFault = CacheSecurityGroupNotFoundFault;
+exports.CacheSecurityGroupNotFoundFault$ = CacheSecurityGroupNotFoundFault$;
+exports.CacheSecurityGroupQuotaExceededFault = CacheSecurityGroupQuotaExceededFault;
+exports.CacheSecurityGroupQuotaExceededFault$ = CacheSecurityGroupQuotaExceededFault$;
+exports.CacheSubnetGroup$ = CacheSubnetGroup$;
+exports.CacheSubnetGroupAlreadyExistsFault = CacheSubnetGroupAlreadyExistsFault;
+exports.CacheSubnetGroupAlreadyExistsFault$ = CacheSubnetGroupAlreadyExistsFault$;
+exports.CacheSubnetGroupInUse = CacheSubnetGroupInUse;
+exports.CacheSubnetGroupInUse$ = CacheSubnetGroupInUse$;
+exports.CacheSubnetGroupMessage$ = CacheSubnetGroupMessage$;
+exports.CacheSubnetGroupNotFoundFault = CacheSubnetGroupNotFoundFault;
+exports.CacheSubnetGroupNotFoundFault$ = CacheSubnetGroupNotFoundFault$;
+exports.CacheSubnetGroupQuotaExceededFault = CacheSubnetGroupQuotaExceededFault;
+exports.CacheSubnetGroupQuotaExceededFault$ = CacheSubnetGroupQuotaExceededFault$;
+exports.CacheSubnetQuotaExceededFault = CacheSubnetQuotaExceededFault;
+exports.CacheSubnetQuotaExceededFault$ = CacheSubnetQuotaExceededFault$;
+exports.CacheUsageLimits$ = CacheUsageLimits$;
 exports.ChangeType = ChangeType;
+exports.CloudWatchLogsDestinationDetails$ = CloudWatchLogsDestinationDetails$;
 exports.ClusterMode = ClusterMode;
+exports.ClusterQuotaForCustomerExceededFault = ClusterQuotaForCustomerExceededFault;
+exports.ClusterQuotaForCustomerExceededFault$ = ClusterQuotaForCustomerExceededFault$;
+exports.CompleteMigration$ = CompleteMigration$;
 exports.CompleteMigrationCommand = CompleteMigrationCommand;
+exports.CompleteMigrationMessage$ = CompleteMigrationMessage$;
+exports.CompleteMigrationResponse$ = CompleteMigrationResponse$;
+exports.ConfigureShard$ = ConfigureShard$;
+exports.CopyServerlessCacheSnapshot$ = CopyServerlessCacheSnapshot$;
 exports.CopyServerlessCacheSnapshotCommand = CopyServerlessCacheSnapshotCommand;
+exports.CopyServerlessCacheSnapshotRequest$ = CopyServerlessCacheSnapshotRequest$;
+exports.CopyServerlessCacheSnapshotResponse$ = CopyServerlessCacheSnapshotResponse$;
+exports.CopySnapshot$ = CopySnapshot$;
 exports.CopySnapshotCommand = CopySnapshotCommand;
+exports.CopySnapshotMessage$ = CopySnapshotMessage$;
+exports.CopySnapshotResult$ = CopySnapshotResult$;
+exports.CreateCacheCluster$ = CreateCacheCluster$;
 exports.CreateCacheClusterCommand = CreateCacheClusterCommand;
+exports.CreateCacheClusterMessage$ = CreateCacheClusterMessage$;
+exports.CreateCacheClusterResult$ = CreateCacheClusterResult$;
+exports.CreateCacheParameterGroup$ = CreateCacheParameterGroup$;
 exports.CreateCacheParameterGroupCommand = CreateCacheParameterGroupCommand;
+exports.CreateCacheParameterGroupMessage$ = CreateCacheParameterGroupMessage$;
+exports.CreateCacheParameterGroupResult$ = CreateCacheParameterGroupResult$;
+exports.CreateCacheSecurityGroup$ = CreateCacheSecurityGroup$;
 exports.CreateCacheSecurityGroupCommand = CreateCacheSecurityGroupCommand;
+exports.CreateCacheSecurityGroupMessage$ = CreateCacheSecurityGroupMessage$;
+exports.CreateCacheSecurityGroupResult$ = CreateCacheSecurityGroupResult$;
+exports.CreateCacheSubnetGroup$ = CreateCacheSubnetGroup$;
 exports.CreateCacheSubnetGroupCommand = CreateCacheSubnetGroupCommand;
+exports.CreateCacheSubnetGroupMessage$ = CreateCacheSubnetGroupMessage$;
+exports.CreateCacheSubnetGroupResult$ = CreateCacheSubnetGroupResult$;
+exports.CreateGlobalReplicationGroup$ = CreateGlobalReplicationGroup$;
 exports.CreateGlobalReplicationGroupCommand = CreateGlobalReplicationGroupCommand;
+exports.CreateGlobalReplicationGroupMessage$ = CreateGlobalReplicationGroupMessage$;
+exports.CreateGlobalReplicationGroupResult$ = CreateGlobalReplicationGroupResult$;
+exports.CreateReplicationGroup$ = CreateReplicationGroup$;
 exports.CreateReplicationGroupCommand = CreateReplicationGroupCommand;
+exports.CreateReplicationGroupMessage$ = CreateReplicationGroupMessage$;
+exports.CreateReplicationGroupResult$ = CreateReplicationGroupResult$;
+exports.CreateServerlessCache$ = CreateServerlessCache$;
 exports.CreateServerlessCacheCommand = CreateServerlessCacheCommand;
+exports.CreateServerlessCacheRequest$ = CreateServerlessCacheRequest$;
+exports.CreateServerlessCacheResponse$ = CreateServerlessCacheResponse$;
+exports.CreateServerlessCacheSnapshot$ = CreateServerlessCacheSnapshot$;
 exports.CreateServerlessCacheSnapshotCommand = CreateServerlessCacheSnapshotCommand;
+exports.CreateServerlessCacheSnapshotRequest$ = CreateServerlessCacheSnapshotRequest$;
+exports.CreateServerlessCacheSnapshotResponse$ = CreateServerlessCacheSnapshotResponse$;
+exports.CreateSnapshot$ = CreateSnapshot$;
 exports.CreateSnapshotCommand = CreateSnapshotCommand;
+exports.CreateSnapshotMessage$ = CreateSnapshotMessage$;
+exports.CreateSnapshotResult$ = CreateSnapshotResult$;
+exports.CreateUser$ = CreateUser$;
 exports.CreateUserCommand = CreateUserCommand;
+exports.CreateUserGroup$ = CreateUserGroup$;
 exports.CreateUserGroupCommand = CreateUserGroupCommand;
+exports.CreateUserGroupMessage$ = CreateUserGroupMessage$;
+exports.CreateUserMessage$ = CreateUserMessage$;
+exports.CustomerNodeEndpoint$ = CustomerNodeEndpoint$;
+exports.DataStorage$ = DataStorage$;
 exports.DataStorageUnit = DataStorageUnit;
 exports.DataTieringStatus = DataTieringStatus;
+exports.DecreaseNodeGroupsInGlobalReplicationGroup$ = DecreaseNodeGroupsInGlobalReplicationGroup$;
 exports.DecreaseNodeGroupsInGlobalReplicationGroupCommand = DecreaseNodeGroupsInGlobalReplicationGroupCommand;
+exports.DecreaseNodeGroupsInGlobalReplicationGroupMessage$ = DecreaseNodeGroupsInGlobalReplicationGroupMessage$;
+exports.DecreaseNodeGroupsInGlobalReplicationGroupResult$ = DecreaseNodeGroupsInGlobalReplicationGroupResult$;
+exports.DecreaseReplicaCount$ = DecreaseReplicaCount$;
 exports.DecreaseReplicaCountCommand = DecreaseReplicaCountCommand;
+exports.DecreaseReplicaCountMessage$ = DecreaseReplicaCountMessage$;
+exports.DecreaseReplicaCountResult$ = DecreaseReplicaCountResult$;
+exports.DefaultUserAssociatedToUserGroupFault = DefaultUserAssociatedToUserGroupFault;
+exports.DefaultUserAssociatedToUserGroupFault$ = DefaultUserAssociatedToUserGroupFault$;
+exports.DefaultUserRequired = DefaultUserRequired;
+exports.DefaultUserRequired$ = DefaultUserRequired$;
+exports.DeleteCacheCluster$ = DeleteCacheCluster$;
 exports.DeleteCacheClusterCommand = DeleteCacheClusterCommand;
+exports.DeleteCacheClusterMessage$ = DeleteCacheClusterMessage$;
+exports.DeleteCacheClusterResult$ = DeleteCacheClusterResult$;
+exports.DeleteCacheParameterGroup$ = DeleteCacheParameterGroup$;
 exports.DeleteCacheParameterGroupCommand = DeleteCacheParameterGroupCommand;
+exports.DeleteCacheParameterGroupMessage$ = DeleteCacheParameterGroupMessage$;
+exports.DeleteCacheSecurityGroup$ = DeleteCacheSecurityGroup$;
 exports.DeleteCacheSecurityGroupCommand = DeleteCacheSecurityGroupCommand;
+exports.DeleteCacheSecurityGroupMessage$ = DeleteCacheSecurityGroupMessage$;
+exports.DeleteCacheSubnetGroup$ = DeleteCacheSubnetGroup$;
 exports.DeleteCacheSubnetGroupCommand = DeleteCacheSubnetGroupCommand;
+exports.DeleteCacheSubnetGroupMessage$ = DeleteCacheSubnetGroupMessage$;
+exports.DeleteGlobalReplicationGroup$ = DeleteGlobalReplicationGroup$;
 exports.DeleteGlobalReplicationGroupCommand = DeleteGlobalReplicationGroupCommand;
+exports.DeleteGlobalReplicationGroupMessage$ = DeleteGlobalReplicationGroupMessage$;
+exports.DeleteGlobalReplicationGroupResult$ = DeleteGlobalReplicationGroupResult$;
+exports.DeleteReplicationGroup$ = DeleteReplicationGroup$;
 exports.DeleteReplicationGroupCommand = DeleteReplicationGroupCommand;
+exports.DeleteReplicationGroupMessage$ = DeleteReplicationGroupMessage$;
+exports.DeleteReplicationGroupResult$ = DeleteReplicationGroupResult$;
+exports.DeleteServerlessCache$ = DeleteServerlessCache$;
 exports.DeleteServerlessCacheCommand = DeleteServerlessCacheCommand;
+exports.DeleteServerlessCacheRequest$ = DeleteServerlessCacheRequest$;
+exports.DeleteServerlessCacheResponse$ = DeleteServerlessCacheResponse$;
+exports.DeleteServerlessCacheSnapshot$ = DeleteServerlessCacheSnapshot$;
 exports.DeleteServerlessCacheSnapshotCommand = DeleteServerlessCacheSnapshotCommand;
+exports.DeleteServerlessCacheSnapshotRequest$ = DeleteServerlessCacheSnapshotRequest$;
+exports.DeleteServerlessCacheSnapshotResponse$ = DeleteServerlessCacheSnapshotResponse$;
+exports.DeleteSnapshot$ = DeleteSnapshot$;
 exports.DeleteSnapshotCommand = DeleteSnapshotCommand;
+exports.DeleteSnapshotMessage$ = DeleteSnapshotMessage$;
+exports.DeleteSnapshotResult$ = DeleteSnapshotResult$;
+exports.DeleteUser$ = DeleteUser$;
 exports.DeleteUserCommand = DeleteUserCommand;
+exports.DeleteUserGroup$ = DeleteUserGroup$;
 exports.DeleteUserGroupCommand = DeleteUserGroupCommand;
+exports.DeleteUserGroupMessage$ = DeleteUserGroupMessage$;
+exports.DeleteUserMessage$ = DeleteUserMessage$;
+exports.DescribeCacheClusters$ = DescribeCacheClusters$;
 exports.DescribeCacheClustersCommand = DescribeCacheClustersCommand;
+exports.DescribeCacheClustersMessage$ = DescribeCacheClustersMessage$;
+exports.DescribeCacheEngineVersions$ = DescribeCacheEngineVersions$;
 exports.DescribeCacheEngineVersionsCommand = DescribeCacheEngineVersionsCommand;
+exports.DescribeCacheEngineVersionsMessage$ = DescribeCacheEngineVersionsMessage$;
+exports.DescribeCacheParameterGroups$ = DescribeCacheParameterGroups$;
 exports.DescribeCacheParameterGroupsCommand = DescribeCacheParameterGroupsCommand;
+exports.DescribeCacheParameterGroupsMessage$ = DescribeCacheParameterGroupsMessage$;
+exports.DescribeCacheParameters$ = DescribeCacheParameters$;
 exports.DescribeCacheParametersCommand = DescribeCacheParametersCommand;
+exports.DescribeCacheParametersMessage$ = DescribeCacheParametersMessage$;
+exports.DescribeCacheSecurityGroups$ = DescribeCacheSecurityGroups$;
 exports.DescribeCacheSecurityGroupsCommand = DescribeCacheSecurityGroupsCommand;
+exports.DescribeCacheSecurityGroupsMessage$ = DescribeCacheSecurityGroupsMessage$;
+exports.DescribeCacheSubnetGroups$ = DescribeCacheSubnetGroups$;
 exports.DescribeCacheSubnetGroupsCommand = DescribeCacheSubnetGroupsCommand;
+exports.DescribeCacheSubnetGroupsMessage$ = DescribeCacheSubnetGroupsMessage$;
+exports.DescribeEngineDefaultParameters$ = DescribeEngineDefaultParameters$;
 exports.DescribeEngineDefaultParametersCommand = DescribeEngineDefaultParametersCommand;
+exports.DescribeEngineDefaultParametersMessage$ = DescribeEngineDefaultParametersMessage$;
+exports.DescribeEngineDefaultParametersResult$ = DescribeEngineDefaultParametersResult$;
+exports.DescribeEvents$ = DescribeEvents$;
 exports.DescribeEventsCommand = DescribeEventsCommand;
+exports.DescribeEventsMessage$ = DescribeEventsMessage$;
+exports.DescribeGlobalReplicationGroups$ = DescribeGlobalReplicationGroups$;
 exports.DescribeGlobalReplicationGroupsCommand = DescribeGlobalReplicationGroupsCommand;
+exports.DescribeGlobalReplicationGroupsMessage$ = DescribeGlobalReplicationGroupsMessage$;
+exports.DescribeGlobalReplicationGroupsResult$ = DescribeGlobalReplicationGroupsResult$;
+exports.DescribeReplicationGroups$ = DescribeReplicationGroups$;
 exports.DescribeReplicationGroupsCommand = DescribeReplicationGroupsCommand;
+exports.DescribeReplicationGroupsMessage$ = DescribeReplicationGroupsMessage$;
+exports.DescribeReservedCacheNodes$ = DescribeReservedCacheNodes$;
 exports.DescribeReservedCacheNodesCommand = DescribeReservedCacheNodesCommand;
+exports.DescribeReservedCacheNodesMessage$ = DescribeReservedCacheNodesMessage$;
+exports.DescribeReservedCacheNodesOfferings$ = DescribeReservedCacheNodesOfferings$;
 exports.DescribeReservedCacheNodesOfferingsCommand = DescribeReservedCacheNodesOfferingsCommand;
+exports.DescribeReservedCacheNodesOfferingsMessage$ = DescribeReservedCacheNodesOfferingsMessage$;
+exports.DescribeServerlessCacheSnapshots$ = DescribeServerlessCacheSnapshots$;
 exports.DescribeServerlessCacheSnapshotsCommand = DescribeServerlessCacheSnapshotsCommand;
+exports.DescribeServerlessCacheSnapshotsRequest$ = DescribeServerlessCacheSnapshotsRequest$;
+exports.DescribeServerlessCacheSnapshotsResponse$ = DescribeServerlessCacheSnapshotsResponse$;
+exports.DescribeServerlessCaches$ = DescribeServerlessCaches$;
 exports.DescribeServerlessCachesCommand = DescribeServerlessCachesCommand;
+exports.DescribeServerlessCachesRequest$ = DescribeServerlessCachesRequest$;
+exports.DescribeServerlessCachesResponse$ = DescribeServerlessCachesResponse$;
+exports.DescribeServiceUpdates$ = DescribeServiceUpdates$;
 exports.DescribeServiceUpdatesCommand = DescribeServiceUpdatesCommand;
+exports.DescribeServiceUpdatesMessage$ = DescribeServiceUpdatesMessage$;
+exports.DescribeSnapshots$ = DescribeSnapshots$;
 exports.DescribeSnapshotsCommand = DescribeSnapshotsCommand;
+exports.DescribeSnapshotsListMessage$ = DescribeSnapshotsListMessage$;
+exports.DescribeSnapshotsMessage$ = DescribeSnapshotsMessage$;
+exports.DescribeUpdateActions$ = DescribeUpdateActions$;
 exports.DescribeUpdateActionsCommand = DescribeUpdateActionsCommand;
+exports.DescribeUpdateActionsMessage$ = DescribeUpdateActionsMessage$;
+exports.DescribeUserGroups$ = DescribeUserGroups$;
 exports.DescribeUserGroupsCommand = DescribeUserGroupsCommand;
+exports.DescribeUserGroupsMessage$ = DescribeUserGroupsMessage$;
+exports.DescribeUserGroupsResult$ = DescribeUserGroupsResult$;
+exports.DescribeUsers$ = DescribeUsers$;
 exports.DescribeUsersCommand = DescribeUsersCommand;
+exports.DescribeUsersMessage$ = DescribeUsersMessage$;
+exports.DescribeUsersResult$ = DescribeUsersResult$;
+exports.DestinationDetails$ = DestinationDetails$;
 exports.DestinationType = DestinationType;
+exports.DisassociateGlobalReplicationGroup$ = DisassociateGlobalReplicationGroup$;
 exports.DisassociateGlobalReplicationGroupCommand = DisassociateGlobalReplicationGroupCommand;
+exports.DisassociateGlobalReplicationGroupMessage$ = DisassociateGlobalReplicationGroupMessage$;
+exports.DisassociateGlobalReplicationGroupResult$ = DisassociateGlobalReplicationGroupResult$;
+exports.DuplicateUserNameFault = DuplicateUserNameFault;
+exports.DuplicateUserNameFault$ = DuplicateUserNameFault$;
 exports.Durability = Durability;
+exports.EC2SecurityGroup$ = EC2SecurityGroup$;
+exports.ECPUPerSecond$ = ECPUPerSecond$;
 exports.EffectiveDurability = EffectiveDurability;
 exports.ElastiCache = ElastiCache;
 exports.ElastiCacheClient = ElastiCacheClient;
+exports.ElastiCacheServiceException = ElastiCacheServiceException;
+exports.ElastiCacheServiceException$ = ElastiCacheServiceException$;
+exports.Endpoint$ = Endpoint$;
+exports.EngineDefaults$ = EngineDefaults$;
+exports.Event$ = Event$;
+exports.EventsMessage$ = EventsMessage$;
+exports.ExportServerlessCacheSnapshot$ = ExportServerlessCacheSnapshot$;
 exports.ExportServerlessCacheSnapshotCommand = ExportServerlessCacheSnapshotCommand;
+exports.ExportServerlessCacheSnapshotRequest$ = ExportServerlessCacheSnapshotRequest$;
+exports.ExportServerlessCacheSnapshotResponse$ = ExportServerlessCacheSnapshotResponse$;
+exports.FailoverGlobalReplicationGroup$ = FailoverGlobalReplicationGroup$;
 exports.FailoverGlobalReplicationGroupCommand = FailoverGlobalReplicationGroupCommand;
+exports.FailoverGlobalReplicationGroupMessage$ = FailoverGlobalReplicationGroupMessage$;
+exports.FailoverGlobalReplicationGroupResult$ = FailoverGlobalReplicationGroupResult$;
+exports.Filter$ = Filter$;
+exports.GlobalNodeGroup$ = GlobalNodeGroup$;
+exports.GlobalReplicationGroup$ = GlobalReplicationGroup$;
+exports.GlobalReplicationGroupAlreadyExistsFault = GlobalReplicationGroupAlreadyExistsFault;
+exports.GlobalReplicationGroupAlreadyExistsFault$ = GlobalReplicationGroupAlreadyExistsFault$;
+exports.GlobalReplicationGroupInfo$ = GlobalReplicationGroupInfo$;
+exports.GlobalReplicationGroupMember$ = GlobalReplicationGroupMember$;
+exports.GlobalReplicationGroupNotFoundFault = GlobalReplicationGroupNotFoundFault;
+exports.GlobalReplicationGroupNotFoundFault$ = GlobalReplicationGroupNotFoundFault$;
+exports.IncreaseNodeGroupsInGlobalReplicationGroup$ = IncreaseNodeGroupsInGlobalReplicationGroup$;
 exports.IncreaseNodeGroupsInGlobalReplicationGroupCommand = IncreaseNodeGroupsInGlobalReplicationGroupCommand;
+exports.IncreaseNodeGroupsInGlobalReplicationGroupMessage$ = IncreaseNodeGroupsInGlobalReplicationGroupMessage$;
+exports.IncreaseNodeGroupsInGlobalReplicationGroupResult$ = IncreaseNodeGroupsInGlobalReplicationGroupResult$;
+exports.IncreaseReplicaCount$ = IncreaseReplicaCount$;
 exports.IncreaseReplicaCountCommand = IncreaseReplicaCountCommand;
+exports.IncreaseReplicaCountMessage$ = IncreaseReplicaCountMessage$;
+exports.IncreaseReplicaCountResult$ = IncreaseReplicaCountResult$;
 exports.InputAuthenticationType = InputAuthenticationType;
+exports.InsufficientCacheClusterCapacityFault = InsufficientCacheClusterCapacityFault;
+exports.InsufficientCacheClusterCapacityFault$ = InsufficientCacheClusterCapacityFault$;
+exports.InvalidARNFault = InvalidARNFault;
+exports.InvalidARNFault$ = InvalidARNFault$;
+exports.InvalidCacheClusterStateFault = InvalidCacheClusterStateFault;
+exports.InvalidCacheClusterStateFault$ = InvalidCacheClusterStateFault$;
+exports.InvalidCacheParameterGroupStateFault = InvalidCacheParameterGroupStateFault;
+exports.InvalidCacheParameterGroupStateFault$ = InvalidCacheParameterGroupStateFault$;
+exports.InvalidCacheSecurityGroupStateFault = InvalidCacheSecurityGroupStateFault;
+exports.InvalidCacheSecurityGroupStateFault$ = InvalidCacheSecurityGroupStateFault$;
+exports.InvalidCredentialsException = InvalidCredentialsException;
+exports.InvalidCredentialsException$ = InvalidCredentialsException$;
+exports.InvalidGlobalReplicationGroupStateFault = InvalidGlobalReplicationGroupStateFault;
+exports.InvalidGlobalReplicationGroupStateFault$ = InvalidGlobalReplicationGroupStateFault$;
+exports.InvalidKMSKeyFault = InvalidKMSKeyFault;
+exports.InvalidKMSKeyFault$ = InvalidKMSKeyFault$;
+exports.InvalidParameterCombinationException = InvalidParameterCombinationException;
+exports.InvalidParameterCombinationException$ = InvalidParameterCombinationException$;
+exports.InvalidParameterValueException = InvalidParameterValueException;
+exports.InvalidParameterValueException$ = InvalidParameterValueException$;
+exports.InvalidReplicationGroupStateFault = InvalidReplicationGroupStateFault;
+exports.InvalidReplicationGroupStateFault$ = InvalidReplicationGroupStateFault$;
+exports.InvalidServerlessCacheSnapshotStateFault = InvalidServerlessCacheSnapshotStateFault;
+exports.InvalidServerlessCacheSnapshotStateFault$ = InvalidServerlessCacheSnapshotStateFault$;
+exports.InvalidServerlessCacheStateFault = InvalidServerlessCacheStateFault;
+exports.InvalidServerlessCacheStateFault$ = InvalidServerlessCacheStateFault$;
+exports.InvalidSnapshotStateFault = InvalidSnapshotStateFault;
+exports.InvalidSnapshotStateFault$ = InvalidSnapshotStateFault$;
+exports.InvalidSubnet = InvalidSubnet;
+exports.InvalidSubnet$ = InvalidSubnet$;
+exports.InvalidUserGroupStateFault = InvalidUserGroupStateFault;
+exports.InvalidUserGroupStateFault$ = InvalidUserGroupStateFault$;
+exports.InvalidUserStateFault = InvalidUserStateFault;
+exports.InvalidUserStateFault$ = InvalidUserStateFault$;
+exports.InvalidVPCNetworkStateFault = InvalidVPCNetworkStateFault;
+exports.InvalidVPCNetworkStateFault$ = InvalidVPCNetworkStateFault$;
 exports.IpDiscovery = IpDiscovery;
+exports.KinesisFirehoseDestinationDetails$ = KinesisFirehoseDestinationDetails$;
+exports.ListAllowedNodeTypeModifications$ = ListAllowedNodeTypeModifications$;
 exports.ListAllowedNodeTypeModificationsCommand = ListAllowedNodeTypeModificationsCommand;
+exports.ListAllowedNodeTypeModificationsMessage$ = ListAllowedNodeTypeModificationsMessage$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceMessage$ = ListTagsForResourceMessage$;
+exports.LogDeliveryConfiguration$ = LogDeliveryConfiguration$;
+exports.LogDeliveryConfigurationRequest$ = LogDeliveryConfigurationRequest$;
 exports.LogDeliveryConfigurationStatus = LogDeliveryConfigurationStatus;
 exports.LogFormat = LogFormat;
 exports.LogType = LogType;
+exports.ModifyCacheCluster$ = ModifyCacheCluster$;
 exports.ModifyCacheClusterCommand = ModifyCacheClusterCommand;
+exports.ModifyCacheClusterMessage$ = ModifyCacheClusterMessage$;
+exports.ModifyCacheClusterResult$ = ModifyCacheClusterResult$;
+exports.ModifyCacheParameterGroup$ = ModifyCacheParameterGroup$;
 exports.ModifyCacheParameterGroupCommand = ModifyCacheParameterGroupCommand;
+exports.ModifyCacheParameterGroupMessage$ = ModifyCacheParameterGroupMessage$;
+exports.ModifyCacheSubnetGroup$ = ModifyCacheSubnetGroup$;
 exports.ModifyCacheSubnetGroupCommand = ModifyCacheSubnetGroupCommand;
+exports.ModifyCacheSubnetGroupMessage$ = ModifyCacheSubnetGroupMessage$;
+exports.ModifyCacheSubnetGroupResult$ = ModifyCacheSubnetGroupResult$;
+exports.ModifyGlobalReplicationGroup$ = ModifyGlobalReplicationGroup$;
 exports.ModifyGlobalReplicationGroupCommand = ModifyGlobalReplicationGroupCommand;
+exports.ModifyGlobalReplicationGroupMessage$ = ModifyGlobalReplicationGroupMessage$;
+exports.ModifyGlobalReplicationGroupResult$ = ModifyGlobalReplicationGroupResult$;
+exports.ModifyReplicationGroup$ = ModifyReplicationGroup$;
 exports.ModifyReplicationGroupCommand = ModifyReplicationGroupCommand;
+exports.ModifyReplicationGroupMessage$ = ModifyReplicationGroupMessage$;
+exports.ModifyReplicationGroupResult$ = ModifyReplicationGroupResult$;
+exports.ModifyReplicationGroupShardConfiguration$ = ModifyReplicationGroupShardConfiguration$;
 exports.ModifyReplicationGroupShardConfigurationCommand = ModifyReplicationGroupShardConfigurationCommand;
+exports.ModifyReplicationGroupShardConfigurationMessage$ = ModifyReplicationGroupShardConfigurationMessage$;
+exports.ModifyReplicationGroupShardConfigurationResult$ = ModifyReplicationGroupShardConfigurationResult$;
+exports.ModifyServerlessCache$ = ModifyServerlessCache$;
 exports.ModifyServerlessCacheCommand = ModifyServerlessCacheCommand;
+exports.ModifyServerlessCacheRequest$ = ModifyServerlessCacheRequest$;
+exports.ModifyServerlessCacheResponse$ = ModifyServerlessCacheResponse$;
+exports.ModifyUser$ = ModifyUser$;
 exports.ModifyUserCommand = ModifyUserCommand;
+exports.ModifyUserGroup$ = ModifyUserGroup$;
 exports.ModifyUserGroupCommand = ModifyUserGroupCommand;
+exports.ModifyUserGroupMessage$ = ModifyUserGroupMessage$;
+exports.ModifyUserMessage$ = ModifyUserMessage$;
 exports.MultiAZStatus = MultiAZStatus;
 exports.NetworkType = NetworkType;
+exports.NoOperationFault = NoOperationFault;
+exports.NoOperationFault$ = NoOperationFault$;
+exports.NodeGroup$ = NodeGroup$;
+exports.NodeGroupConfiguration$ = NodeGroupConfiguration$;
+exports.NodeGroupMember$ = NodeGroupMember$;
+exports.NodeGroupMemberUpdateStatus$ = NodeGroupMemberUpdateStatus$;
+exports.NodeGroupNotFoundFault = NodeGroupNotFoundFault;
+exports.NodeGroupNotFoundFault$ = NodeGroupNotFoundFault$;
+exports.NodeGroupUpdateStatus$ = NodeGroupUpdateStatus$;
+exports.NodeGroupsPerReplicationGroupQuotaExceededFault = NodeGroupsPerReplicationGroupQuotaExceededFault;
+exports.NodeGroupsPerReplicationGroupQuotaExceededFault$ = NodeGroupsPerReplicationGroupQuotaExceededFault$;
+exports.NodeQuotaForClusterExceededFault = NodeQuotaForClusterExceededFault;
+exports.NodeQuotaForClusterExceededFault$ = NodeQuotaForClusterExceededFault$;
+exports.NodeQuotaForCustomerExceededFault = NodeQuotaForCustomerExceededFault;
+exports.NodeQuotaForCustomerExceededFault$ = NodeQuotaForCustomerExceededFault$;
+exports.NodeSnapshot$ = NodeSnapshot$;
 exports.NodeUpdateInitiatedBy = NodeUpdateInitiatedBy;
 exports.NodeUpdateStatus = NodeUpdateStatus;
+exports.NotificationConfiguration$ = NotificationConfiguration$;
 exports.OutpostMode = OutpostMode;
+exports.Parameter$ = Parameter$;
+exports.ParameterNameValue$ = ParameterNameValue$;
 exports.PendingAutomaticFailoverStatus = PendingAutomaticFailoverStatus;
+exports.PendingLogDeliveryConfiguration$ = PendingLogDeliveryConfiguration$;
+exports.PendingModifiedValues$ = PendingModifiedValues$;
+exports.ProcessedUpdateAction$ = ProcessedUpdateAction$;
+exports.PurchaseReservedCacheNodesOffering$ = PurchaseReservedCacheNodesOffering$;
 exports.PurchaseReservedCacheNodesOfferingCommand = PurchaseReservedCacheNodesOfferingCommand;
+exports.PurchaseReservedCacheNodesOfferingMessage$ = PurchaseReservedCacheNodesOfferingMessage$;
+exports.PurchaseReservedCacheNodesOfferingResult$ = PurchaseReservedCacheNodesOfferingResult$;
+exports.RebalanceSlotsInGlobalReplicationGroup$ = RebalanceSlotsInGlobalReplicationGroup$;
 exports.RebalanceSlotsInGlobalReplicationGroupCommand = RebalanceSlotsInGlobalReplicationGroupCommand;
+exports.RebalanceSlotsInGlobalReplicationGroupMessage$ = RebalanceSlotsInGlobalReplicationGroupMessage$;
+exports.RebalanceSlotsInGlobalReplicationGroupResult$ = RebalanceSlotsInGlobalReplicationGroupResult$;
+exports.RebootCacheCluster$ = RebootCacheCluster$;
 exports.RebootCacheClusterCommand = RebootCacheClusterCommand;
+exports.RebootCacheClusterMessage$ = RebootCacheClusterMessage$;
+exports.RebootCacheClusterResult$ = RebootCacheClusterResult$;
+exports.RecurringCharge$ = RecurringCharge$;
+exports.RegionalConfiguration$ = RegionalConfiguration$;
+exports.RemoveTagsFromResource$ = RemoveTagsFromResource$;
 exports.RemoveTagsFromResourceCommand = RemoveTagsFromResourceCommand;
+exports.RemoveTagsFromResourceMessage$ = RemoveTagsFromResourceMessage$;
+exports.ReplicationGroup$ = ReplicationGroup$;
+exports.ReplicationGroupAlreadyExistsFault = ReplicationGroupAlreadyExistsFault;
+exports.ReplicationGroupAlreadyExistsFault$ = ReplicationGroupAlreadyExistsFault$;
+exports.ReplicationGroupAlreadyUnderMigrationFault = ReplicationGroupAlreadyUnderMigrationFault;
+exports.ReplicationGroupAlreadyUnderMigrationFault$ = ReplicationGroupAlreadyUnderMigrationFault$;
+exports.ReplicationGroupMessage$ = ReplicationGroupMessage$;
+exports.ReplicationGroupNotFoundFault = ReplicationGroupNotFoundFault;
+exports.ReplicationGroupNotFoundFault$ = ReplicationGroupNotFoundFault$;
+exports.ReplicationGroupNotUnderMigrationFault = ReplicationGroupNotUnderMigrationFault;
+exports.ReplicationGroupNotUnderMigrationFault$ = ReplicationGroupNotUnderMigrationFault$;
+exports.ReplicationGroupPendingModifiedValues$ = ReplicationGroupPendingModifiedValues$;
+exports.ReservedCacheNode$ = ReservedCacheNode$;
+exports.ReservedCacheNodeAlreadyExistsFault = ReservedCacheNodeAlreadyExistsFault;
+exports.ReservedCacheNodeAlreadyExistsFault$ = ReservedCacheNodeAlreadyExistsFault$;
+exports.ReservedCacheNodeMessage$ = ReservedCacheNodeMessage$;
+exports.ReservedCacheNodeNotFoundFault = ReservedCacheNodeNotFoundFault;
+exports.ReservedCacheNodeNotFoundFault$ = ReservedCacheNodeNotFoundFault$;
+exports.ReservedCacheNodeQuotaExceededFault = ReservedCacheNodeQuotaExceededFault;
+exports.ReservedCacheNodeQuotaExceededFault$ = ReservedCacheNodeQuotaExceededFault$;
+exports.ReservedCacheNodesOffering$ = ReservedCacheNodesOffering$;
+exports.ReservedCacheNodesOfferingMessage$ = ReservedCacheNodesOfferingMessage$;
+exports.ReservedCacheNodesOfferingNotFoundFault = ReservedCacheNodesOfferingNotFoundFault;
+exports.ReservedCacheNodesOfferingNotFoundFault$ = ReservedCacheNodesOfferingNotFoundFault$;
+exports.ResetCacheParameterGroup$ = ResetCacheParameterGroup$;
 exports.ResetCacheParameterGroupCommand = ResetCacheParameterGroupCommand;
+exports.ResetCacheParameterGroupMessage$ = ResetCacheParameterGroupMessage$;
+exports.ReshardingConfiguration$ = ReshardingConfiguration$;
+exports.ReshardingStatus$ = ReshardingStatus$;
+exports.RevokeCacheSecurityGroupIngress$ = RevokeCacheSecurityGroupIngress$;
 exports.RevokeCacheSecurityGroupIngressCommand = RevokeCacheSecurityGroupIngressCommand;
+exports.RevokeCacheSecurityGroupIngressMessage$ = RevokeCacheSecurityGroupIngressMessage$;
+exports.RevokeCacheSecurityGroupIngressResult$ = RevokeCacheSecurityGroupIngressResult$;
+exports.ScaleConfig$ = ScaleConfig$;
+exports.SecurityGroupMembership$ = SecurityGroupMembership$;
+exports.ServerlessCache$ = ServerlessCache$;
+exports.ServerlessCacheAlreadyExistsFault = ServerlessCacheAlreadyExistsFault;
+exports.ServerlessCacheAlreadyExistsFault$ = ServerlessCacheAlreadyExistsFault$;
+exports.ServerlessCacheConfiguration$ = ServerlessCacheConfiguration$;
+exports.ServerlessCacheNotFoundFault = ServerlessCacheNotFoundFault;
+exports.ServerlessCacheNotFoundFault$ = ServerlessCacheNotFoundFault$;
+exports.ServerlessCacheQuotaForCustomerExceededFault = ServerlessCacheQuotaForCustomerExceededFault;
+exports.ServerlessCacheQuotaForCustomerExceededFault$ = ServerlessCacheQuotaForCustomerExceededFault$;
+exports.ServerlessCacheSnapshot$ = ServerlessCacheSnapshot$;
+exports.ServerlessCacheSnapshotAlreadyExistsFault = ServerlessCacheSnapshotAlreadyExistsFault;
+exports.ServerlessCacheSnapshotAlreadyExistsFault$ = ServerlessCacheSnapshotAlreadyExistsFault$;
+exports.ServerlessCacheSnapshotNotFoundFault = ServerlessCacheSnapshotNotFoundFault;
+exports.ServerlessCacheSnapshotNotFoundFault$ = ServerlessCacheSnapshotNotFoundFault$;
+exports.ServerlessCacheSnapshotQuotaExceededFault = ServerlessCacheSnapshotQuotaExceededFault;
+exports.ServerlessCacheSnapshotQuotaExceededFault$ = ServerlessCacheSnapshotQuotaExceededFault$;
+exports.ServiceLinkedRoleNotFoundFault = ServiceLinkedRoleNotFoundFault;
+exports.ServiceLinkedRoleNotFoundFault$ = ServiceLinkedRoleNotFoundFault$;
+exports.ServiceUpdate$ = ServiceUpdate$;
+exports.ServiceUpdateNotFoundFault = ServiceUpdateNotFoundFault;
+exports.ServiceUpdateNotFoundFault$ = ServiceUpdateNotFoundFault$;
 exports.ServiceUpdateSeverity = ServiceUpdateSeverity;
 exports.ServiceUpdateStatus = ServiceUpdateStatus;
 exports.ServiceUpdateType = ServiceUpdateType;
+exports.ServiceUpdatesMessage$ = ServiceUpdatesMessage$;
 exports.SlaMet = SlaMet;
+exports.SlotMigration$ = SlotMigration$;
+exports.Snapshot$ = Snapshot$;
+exports.SnapshotAlreadyExistsFault = SnapshotAlreadyExistsFault;
+exports.SnapshotAlreadyExistsFault$ = SnapshotAlreadyExistsFault$;
+exports.SnapshotFeatureNotSupportedFault = SnapshotFeatureNotSupportedFault;
+exports.SnapshotFeatureNotSupportedFault$ = SnapshotFeatureNotSupportedFault$;
+exports.SnapshotNotFoundFault = SnapshotNotFoundFault;
+exports.SnapshotNotFoundFault$ = SnapshotNotFoundFault$;
+exports.SnapshotQuotaExceededFault = SnapshotQuotaExceededFault;
+exports.SnapshotQuotaExceededFault$ = SnapshotQuotaExceededFault$;
 exports.SourceType = SourceType;
+exports.StartMigration$ = StartMigration$;
 exports.StartMigrationCommand = StartMigrationCommand;
+exports.StartMigrationMessage$ = StartMigrationMessage$;
+exports.StartMigrationResponse$ = StartMigrationResponse$;
 exports.StorageEncryptionType = StorageEncryptionType;
+exports.Subnet$ = Subnet$;
+exports.SubnetInUse = SubnetInUse;
+exports.SubnetInUse$ = SubnetInUse$;
+exports.SubnetNotAllowedFault = SubnetNotAllowedFault;
+exports.SubnetNotAllowedFault$ = SubnetNotAllowedFault$;
+exports.SubnetOutpost$ = SubnetOutpost$;
+exports.Tag$ = Tag$;
+exports.TagListMessage$ = TagListMessage$;
+exports.TagNotFoundFault = TagNotFoundFault;
+exports.TagNotFoundFault$ = TagNotFoundFault$;
+exports.TagQuotaPerResourceExceeded = TagQuotaPerResourceExceeded;
+exports.TagQuotaPerResourceExceeded$ = TagQuotaPerResourceExceeded$;
+exports.TestFailover$ = TestFailover$;
 exports.TestFailoverCommand = TestFailoverCommand;
+exports.TestFailoverMessage$ = TestFailoverMessage$;
+exports.TestFailoverNotAvailableFault = TestFailoverNotAvailableFault;
+exports.TestFailoverNotAvailableFault$ = TestFailoverNotAvailableFault$;
+exports.TestFailoverResult$ = TestFailoverResult$;
+exports.TestMigration$ = TestMigration$;
 exports.TestMigrationCommand = TestMigrationCommand;
+exports.TestMigrationMessage$ = TestMigrationMessage$;
+exports.TestMigrationResponse$ = TestMigrationResponse$;
+exports.TimeRangeFilter$ = TimeRangeFilter$;
 exports.TransitEncryptionMode = TransitEncryptionMode;
+exports.UnprocessedUpdateAction$ = UnprocessedUpdateAction$;
+exports.UpdateAction$ = UpdateAction$;
+exports.UpdateActionResultsMessage$ = UpdateActionResultsMessage$;
 exports.UpdateActionStatus = UpdateActionStatus;
+exports.UpdateActionsMessage$ = UpdateActionsMessage$;
+exports.User$ = User$;
+exports.UserAlreadyExistsFault = UserAlreadyExistsFault;
+exports.UserAlreadyExistsFault$ = UserAlreadyExistsFault$;
+exports.UserGroup$ = UserGroup$;
+exports.UserGroupAlreadyExistsFault = UserGroupAlreadyExistsFault;
+exports.UserGroupAlreadyExistsFault$ = UserGroupAlreadyExistsFault$;
+exports.UserGroupNotFoundFault = UserGroupNotFoundFault;
+exports.UserGroupNotFoundFault$ = UserGroupNotFoundFault$;
+exports.UserGroupPendingChanges$ = UserGroupPendingChanges$;
+exports.UserGroupQuotaExceededFault = UserGroupQuotaExceededFault;
+exports.UserGroupQuotaExceededFault$ = UserGroupQuotaExceededFault$;
+exports.UserGroupsUpdateStatus$ = UserGroupsUpdateStatus$;
+exports.UserNotFoundFault = UserNotFoundFault;
+exports.UserNotFoundFault$ = UserNotFoundFault$;
+exports.UserQuotaExceededFault = UserQuotaExceededFault;
+exports.UserQuotaExceededFault$ = UserQuotaExceededFault$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateDescribeCacheClusters = paginateDescribeCacheClusters;
 exports.paginateDescribeCacheEngineVersions = paginateDescribeCacheEngineVersions;
 exports.paginateDescribeCacheParameterGroups = paginateDescribeCacheParameterGroups;