import type { 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>);
}