@aws-sdk/client-elasticache 3.934.0 → 3.935.0

package/dist-types/models/errors.d.ts

@@ -0,0 +1,952 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ElastiCacheServiceException as __BaseException } from "./ElastiCacheServiceException";
+/**
+ * <p>The requested cluster ID does not refer to an existing cluster.</p>
+ * @public
+ */
+export declare class CacheClusterNotFoundFault extends __BaseException {
+    readonly name: "CacheClusterNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheClusterNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested cache parameter group name does not refer to an existing cache parameter
+ *             group.</p>
+ * @public
+ */
+export declare class CacheParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "CacheParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheParameterGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested cache security group name does not refer to an existing cache security
+ *             group.</p>
+ * @public
+ */
+export declare class CacheSecurityGroupNotFoundFault extends __BaseException {
+    readonly name: "CacheSecurityGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSecurityGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested cache subnet group name does not refer to an existing cache subnet
+ *             group.</p>
+ * @public
+ */
+export declare class CacheSubnetGroupNotFoundFault extends __BaseException {
+    readonly name: "CacheSubnetGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSubnetGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested Amazon Resource Name (ARN) does not refer to an existing
+ *             resource.</p>
+ * @public
+ */
+export declare class InvalidARNFault extends __BaseException {
+    readonly name: "InvalidARNFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidARNFault, __BaseException>);
+}
+/**
+ * <p>The requested replication group is not in the <code>available</code> state.</p>
+ * @public
+ */
+export declare class InvalidReplicationGroupStateFault extends __BaseException {
+    readonly name: "InvalidReplicationGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidReplicationGroupStateFault, __BaseException>);
+}
+/**
+ * <p>The state of the serverless cache snapshot was not received. Available for Valkey, Redis OSS and Serverless Memcached only.</p>
+ * @public
+ */
+export declare class InvalidServerlessCacheSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidServerlessCacheSnapshotStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidServerlessCacheSnapshotStateFault, __BaseException>);
+}
+/**
+ * <p>The account for these credentials is not currently active.</p>
+ * @public
+ */
+export declare class InvalidServerlessCacheStateFault extends __BaseException {
+    readonly name: "InvalidServerlessCacheStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidServerlessCacheStateFault, __BaseException>);
+}
+/**
+ * <p>The specified replication group does not exist.</p>
+ * @public
+ */
+export declare class ReplicationGroupNotFoundFault extends __BaseException {
+    readonly name: "ReplicationGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested reserved cache node was not found.</p>
+ * @public
+ */
+export declare class ReservedCacheNodeNotFoundFault extends __BaseException {
+    readonly name: "ReservedCacheNodeNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReservedCacheNodeNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The serverless cache was not found or does not exist.</p>
+ * @public
+ */
+export declare class ServerlessCacheNotFoundFault extends __BaseException {
+    readonly name: "ServerlessCacheNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheNotFoundFault, __BaseException>);
+}
+/**
+ * <p>This serverless cache snapshot could not be found or does not exist. Available for Valkey, Redis OSS and Serverless Memcached only.</p>
+ * @public
+ */
+export declare class ServerlessCacheSnapshotNotFoundFault extends __BaseException {
+    readonly name: "ServerlessCacheSnapshotNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheSnapshotNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested snapshot name does not refer to an existing snapshot.</p>
+ * @public
+ */
+export declare class SnapshotNotFoundFault extends __BaseException {
+    readonly name: "SnapshotNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SnapshotNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would cause the resource to have more than
+ *             the allowed number of tags. The maximum number of tags permitted on a resource is
+ *             50.</p>
+ * @public
+ */
+export declare class TagQuotaPerResourceExceeded extends __BaseException {
+    readonly name: "TagQuotaPerResourceExceeded";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TagQuotaPerResourceExceeded, __BaseException>);
+}
+/**
+ * <p>The user group was not found or does not exist</p>
+ * @public
+ */
+export declare class UserGroupNotFoundFault extends __BaseException {
+    readonly name: "UserGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The user does not exist or could not be found.</p>
+ * @public
+ */
+export declare class UserNotFoundFault extends __BaseException {
+    readonly name: "UserNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The specified Amazon EC2 security group is already authorized for the specified cache
+ *             security group.</p>
+ * @public
+ */
+export declare class AuthorizationAlreadyExistsFault extends __BaseException {
+    readonly name: "AuthorizationAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AuthorizationAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The current state of the cache security group does not allow deletion.</p>
+ * @public
+ */
+export declare class InvalidCacheSecurityGroupStateFault extends __BaseException {
+    readonly name: "InvalidCacheSecurityGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidCacheSecurityGroupStateFault, __BaseException>);
+}
+/**
+ * <p>Two or more incompatible parameters were specified.</p>
+ * @public
+ */
+export declare class InvalidParameterCombinationException extends __BaseException {
+    readonly name: "InvalidParameterCombinationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidParameterCombinationException, __BaseException>);
+}
+/**
+ * <p>The value for a parameter is invalid.</p>
+ * @public
+ */
+export declare class InvalidParameterValueException extends __BaseException {
+    readonly name: "InvalidParameterValueException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>);
+}
+/**
+ * <p>The service update doesn't exist</p>
+ * @public
+ */
+export declare class ServiceUpdateNotFoundFault extends __BaseException {
+    readonly name: "ServiceUpdateNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceUpdateNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The designated replication group is not available for data migration.</p>
+ * @public
+ */
+export declare class ReplicationGroupNotUnderMigrationFault extends __BaseException {
+    readonly name: "ReplicationGroupNotUnderMigrationFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationGroupNotUnderMigrationFault, __BaseException>);
+}
+/**
+ * <p>A serverless cache snapshot with this name already exists. Available for Valkey, Redis OSS and Serverless Memcached only.</p>
+ * @public
+ */
+export declare class ServerlessCacheSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "ServerlessCacheSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheSnapshotAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The number of serverless cache snapshots exceeds the customer snapshot quota. Available for Valkey, Redis OSS and Serverless Memcached only.</p>
+ * @public
+ */
+export declare class ServerlessCacheSnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "ServerlessCacheSnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheSnapshotQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The specified service linked role (SLR) was not found.</p>
+ * @public
+ */
+export declare class ServiceLinkedRoleNotFoundFault extends __BaseException {
+    readonly name: "ServiceLinkedRoleNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceLinkedRoleNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The current state of the snapshot does not allow the requested operation to
+ *             occur.</p>
+ * @public
+ */
+export declare class InvalidSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidSnapshotStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSnapshotStateFault, __BaseException>);
+}
+/**
+ * <p>You already have a snapshot with the given name.</p>
+ * @public
+ */
+export declare class SnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "SnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SnapshotAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the maximum number of
+ *             snapshots.</p>
+ * @public
+ */
+export declare class SnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SnapshotQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>You already have a cluster with the given identifier.</p>
+ * @public
+ */
+export declare class CacheClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "CacheClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheClusterAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of clusters
+ *             per customer.</p>
+ * @public
+ */
+export declare class ClusterQuotaForCustomerExceededFault extends __BaseException {
+    readonly name: "ClusterQuotaForCustomerExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ClusterQuotaForCustomerExceededFault, __BaseException>);
+}
+/**
+ * <p>The requested cache node type is not available in the specified Availability Zone. For
+ *             more information, see <a href="http://docs.aws.amazon.com/AmazonElastiCache/latest/dg/ErrorMessages.html#ErrorMessages.INSUFFICIENT_CACHE_CLUSTER_CAPACITY">InsufficientCacheClusterCapacity</a> in the ElastiCache User Guide.</p>
+ * @public
+ */
+export declare class InsufficientCacheClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientCacheClusterCapacityFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InsufficientCacheClusterCapacityFault, __BaseException>);
+}
+/**
+ * <p>The VPC network is in an invalid state.</p>
+ * @public
+ */
+export declare class InvalidVPCNetworkStateFault extends __BaseException {
+    readonly name: "InvalidVPCNetworkStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of cache
+ *             nodes in a single cluster.</p>
+ * @public
+ */
+export declare class NodeQuotaForClusterExceededFault extends __BaseException {
+    readonly name: "NodeQuotaForClusterExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NodeQuotaForClusterExceededFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of cache
+ *             nodes per customer.</p>
+ * @public
+ */
+export declare class NodeQuotaForCustomerExceededFault extends __BaseException {
+    readonly name: "NodeQuotaForCustomerExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NodeQuotaForCustomerExceededFault, __BaseException>);
+}
+/**
+ * <p>A cache parameter group with the requested name already exists.</p>
+ * @public
+ */
+export declare class CacheParameterGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "CacheParameterGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheParameterGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the maximum number of cache
+ *             security groups.</p>
+ * @public
+ */
+export declare class CacheParameterGroupQuotaExceededFault extends __BaseException {
+    readonly name: "CacheParameterGroupQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheParameterGroupQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The current state of the cache parameter group does not allow the requested operation
+ *             to occur.</p>
+ * @public
+ */
+export declare class InvalidCacheParameterGroupStateFault extends __BaseException {
+    readonly name: "InvalidCacheParameterGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidCacheParameterGroupStateFault, __BaseException>);
+}
+/**
+ * <p>A cache security group with the specified name already exists.</p>
+ * @public
+ */
+export declare class CacheSecurityGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "CacheSecurityGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSecurityGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of cache
+ *             security groups.</p>
+ * @public
+ */
+export declare class CacheSecurityGroupQuotaExceededFault extends __BaseException {
+    readonly name: "CacheSecurityGroupQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSecurityGroupQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The requested cache subnet group name is already in use by an existing cache subnet
+ *             group.</p>
+ * @public
+ */
+export declare class CacheSubnetGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "CacheSubnetGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSubnetGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of cache
+ *             subnet groups.</p>
+ * @public
+ */
+export declare class CacheSubnetGroupQuotaExceededFault extends __BaseException {
+    readonly name: "CacheSubnetGroupQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSubnetGroupQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the allowed number of subnets
+ *             in a cache subnet group.</p>
+ * @public
+ */
+export declare class CacheSubnetQuotaExceededFault extends __BaseException {
+    readonly name: "CacheSubnetQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSubnetQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>An invalid subnet identifier was specified.</p>
+ * @public
+ */
+export declare class InvalidSubnet extends __BaseException {
+    readonly name: "InvalidSubnet";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
+}
+/**
+ * <p>At least one subnet ID does not match the other subnet IDs. This mismatch typically
+ *             occurs when a user sets one subnet ID to a regional Availability Zone and a different
+ *             one to an outpost. Or when a user sets the subnet ID to an Outpost when not subscribed
+ *             on this service.</p>
+ * @public
+ */
+export declare class SubnetNotAllowedFault extends __BaseException {
+    readonly name: "SubnetNotAllowedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubnetNotAllowedFault, __BaseException>);
+}
+/**
+ * <p>The Global datastore name already exists.</p>
+ * @public
+ */
+export declare class GlobalReplicationGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "GlobalReplicationGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<GlobalReplicationGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The Global datastore does not exist</p>
+ * @public
+ */
+export declare class GlobalReplicationGroupNotFoundFault extends __BaseException {
+    readonly name: "GlobalReplicationGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<GlobalReplicationGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The requested cluster is not in the <code>available</code> state.</p>
+ * @public
+ */
+export declare class InvalidCacheClusterStateFault extends __BaseException {
+    readonly name: "InvalidCacheClusterStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidCacheClusterStateFault, __BaseException>);
+}
+/**
+ * <p>The Global datastore is not available or in primary-only state.</p>
+ * @public
+ */
+export declare class InvalidGlobalReplicationGroupStateFault extends __BaseException {
+    readonly name: "InvalidGlobalReplicationGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidGlobalReplicationGroupStateFault, __BaseException>);
+}
+/**
+ * <p>The user group is not in an active state.</p>
+ * @public
+ */
+export declare class InvalidUserGroupStateFault extends __BaseException {
+    readonly name: "InvalidUserGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidUserGroupStateFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the maximum allowed number of
+ *             node groups (shards) in a single replication group. The default maximum is 90</p>
+ * @public
+ */
+export declare class NodeGroupsPerReplicationGroupQuotaExceededFault extends __BaseException {
+    readonly name: "NodeGroupsPerReplicationGroupQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NodeGroupsPerReplicationGroupQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The specified replication group already exists.</p>
+ * @public
+ */
+export declare class ReplicationGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "ReplicationGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>You must enter valid credentials.</p>
+ * @public
+ */
+export declare class InvalidCredentialsException extends __BaseException {
+    readonly name: "InvalidCredentialsException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidCredentialsException, __BaseException>);
+}
+/**
+ * <p>A serverless cache with this name already exists.</p>
+ * @public
+ */
+export declare class ServerlessCacheAlreadyExistsFault extends __BaseException {
+    readonly name: "ServerlessCacheAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The number of serverless caches exceeds the customer quota.</p>
+ * @public
+ */
+export declare class ServerlessCacheQuotaForCustomerExceededFault extends __BaseException {
+    readonly name: "ServerlessCacheQuotaForCustomerExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServerlessCacheQuotaForCustomerExceededFault, __BaseException>);
+}
+/**
+ * <p>You attempted one of the following operations:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Creating a snapshot of a Valkey or Redis OSS cluster running on a
+ *                         <code>cache.t1.micro</code> cache node.</p>
+ *             </li>
+ *             <li>
+ *                <p>Creating a snapshot of a cluster that is running Memcached rather than
+ *                     Valkey or Redis OSS.</p>
+ *             </li>
+ *          </ul>
+ *          <p>Neither of these are supported by ElastiCache.</p>
+ * @public
+ */
+export declare class SnapshotFeatureNotSupportedFault extends __BaseException {
+    readonly name: "SnapshotFeatureNotSupportedFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SnapshotFeatureNotSupportedFault, __BaseException>);
+}
+/**
+ * <p>A user with this username already exists.</p>
+ * @public
+ */
+export declare class DuplicateUserNameFault extends __BaseException {
+    readonly name: "DuplicateUserNameFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DuplicateUserNameFault, __BaseException>);
+}
+/**
+ * <p>A user with this ID already exists.</p>
+ * @public
+ */
+export declare class UserAlreadyExistsFault extends __BaseException {
+    readonly name: "UserAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The quota of users has been exceeded.</p>
+ * @public
+ */
+export declare class UserQuotaExceededFault extends __BaseException {
+    readonly name: "UserQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>You must add default user to a user group.</p>
+ * @public
+ */
+export declare class DefaultUserRequired extends __BaseException {
+    readonly name: "DefaultUserRequired";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DefaultUserRequired, __BaseException>);
+}
+/**
+ * <p>The user group with this ID already exists.</p>
+ * @public
+ */
+export declare class UserGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "UserGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserGroupAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The number of users exceeds the user group limit.</p>
+ * @public
+ */
+export declare class UserGroupQuotaExceededFault extends __BaseException {
+    readonly name: "UserGroupQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UserGroupQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The operation was not performed because no changes were required.</p>
+ * @public
+ */
+export declare class NoOperationFault extends __BaseException {
+    readonly name: "NoOperationFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NoOperationFault, __BaseException>);
+}
+/**
+ * <p>The requested cache subnet group is currently in use.</p>
+ * @public
+ */
+export declare class CacheSubnetGroupInUse extends __BaseException {
+    readonly name: "CacheSubnetGroupInUse";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CacheSubnetGroupInUse, __BaseException>);
+}
+/**
+ * <p>The default user assigned to the user group.</p>
+ * @public
+ */
+export declare class DefaultUserAssociatedToUserGroupFault extends __BaseException {
+    readonly name: "DefaultUserAssociatedToUserGroupFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DefaultUserAssociatedToUserGroupFault, __BaseException>);
+}
+/**
+ * <p>The user is not in active state.</p>
+ * @public
+ */
+export declare class InvalidUserStateFault extends __BaseException {
+    readonly name: "InvalidUserStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidUserStateFault, __BaseException>);
+}
+/**
+ * <p>The requested cache node offering does not exist.</p>
+ * @public
+ */
+export declare class ReservedCacheNodesOfferingNotFoundFault extends __BaseException {
+    readonly name: "ReservedCacheNodesOfferingNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReservedCacheNodesOfferingNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The KMS key supplied is not valid.</p>
+ * @public
+ */
+export declare class InvalidKMSKeyFault extends __BaseException {
+    readonly name: "InvalidKMSKeyFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidKMSKeyFault, __BaseException>);
+}
+/**
+ * <p>The requested subnet is being used by another cache subnet group.</p>
+ * @public
+ */
+export declare class SubnetInUse extends __BaseException {
+    readonly name: "SubnetInUse";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubnetInUse, __BaseException>);
+}
+/**
+ * <p>You already have a reservation with the given identifier.</p>
+ * @public
+ */
+export declare class ReservedCacheNodeAlreadyExistsFault extends __BaseException {
+    readonly name: "ReservedCacheNodeAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReservedCacheNodeAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The request cannot be processed because it would exceed the user's cache node
+ *             quota.</p>
+ * @public
+ */
+export declare class ReservedCacheNodeQuotaExceededFault extends __BaseException {
+    readonly name: "ReservedCacheNodeQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReservedCacheNodeQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The requested tag was not found on this resource.</p>
+ * @public
+ */
+export declare class TagNotFoundFault extends __BaseException {
+    readonly name: "TagNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TagNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The specified Amazon EC2 security group is not authorized for the specified cache
+ *             security group.</p>
+ * @public
+ */
+export declare class AuthorizationNotFoundFault extends __BaseException {
+    readonly name: "AuthorizationNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The targeted replication group is not available. </p>
+ * @public
+ */
+export declare class ReplicationGroupAlreadyUnderMigrationFault extends __BaseException {
+    readonly name: "ReplicationGroupAlreadyUnderMigrationFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationGroupAlreadyUnderMigrationFault, __BaseException>);
+}
+/**
+ * <p>The customer has exceeded the allowed rate of API calls.</p>
+ * @public
+ */
+export declare class APICallRateForCustomerExceededFault extends __BaseException {
+    readonly name: "APICallRateForCustomerExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<APICallRateForCustomerExceededFault, __BaseException>);
+}
+/**
+ * <p>The node group specified by the <code>NodeGroupId</code> parameter could not be found.
+ *             Please verify that the node group exists and that you spelled the
+ *                 <code>NodeGroupId</code> value correctly.</p>
+ * @public
+ */
+export declare class NodeGroupNotFoundFault extends __BaseException {
+    readonly name: "NodeGroupNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NodeGroupNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The <code>TestFailover</code> action is not available.</p>
+ * @public
+ */
+export declare class TestFailoverNotAvailableFault extends __BaseException {
+    readonly name: "TestFailoverNotAvailableFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TestFailoverNotAvailableFault, __BaseException>);
+}