import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/core/client";
import { DocDBServiceException as __BaseException } from "./DocDBServiceException";
/**
 * <p>The requested source could not be found. </p>
 * @public
 */
export declare class SourceNotFoundFault extends __BaseException {
    readonly name: "SourceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SourceNotFoundFault, __BaseException>);
}
/**
 * <p>The subscription name does not exist. </p>
 * @public
 */
export declare class SubscriptionNotFoundFault extends __BaseException {
    readonly name: "SubscriptionNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBClusterIdentifier</code> doesn't refer to an existing cluster. </p>
 * @public
 */
export declare class DBClusterNotFoundFault extends __BaseException {
    readonly name: "DBClusterNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterNotFoundFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBInstanceIdentifier</code> doesn't refer to an existing instance. </p>
 * @public
 */
export declare class DBInstanceNotFoundFault extends __BaseException {
    readonly name: "DBInstanceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceNotFoundFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBSnapshotIdentifier</code> doesn't refer to an existing snapshot. </p>
 * @public
 */
export declare class DBSnapshotNotFoundFault extends __BaseException {
    readonly name: "DBSnapshotNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSnapshotNotFoundFault, __BaseException>);
}
/**
 * <p>The cluster isn't in a valid state.</p>
 * @public
 */
export declare class InvalidDBClusterStateFault extends __BaseException {
    readonly name: "InvalidDBClusterStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterStateFault, __BaseException>);
}
/**
 * <p> The specified instance isn't in the <i>available</i> state.
 *         </p>
 * @public
 */
export declare class InvalidDBInstanceStateFault extends __BaseException {
    readonly name: "InvalidDBInstanceStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBInstanceStateFault, __BaseException>);
}
/**
 * <p>The specified resource ID was not found.</p>
 * @public
 */
export declare class ResourceNotFoundFault extends __BaseException {
    readonly name: "ResourceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
}
/**
 * <p>A parameter group with the same name already exists.</p>
 * @public
 */
export declare class DBParameterGroupAlreadyExistsFault extends __BaseException {
    readonly name: "DBParameterGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBParameterGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBParameterGroupName</code> doesn't refer to an existing parameter group. </p>
 * @public
 */
export declare class DBParameterGroupNotFoundFault extends __BaseException {
    readonly name: "DBParameterGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBParameterGroupNotFoundFault, __BaseException>);
}
/**
 * <p>This request would cause you to exceed the allowed number of parameter groups.</p>
 * @public
 */
export declare class DBParameterGroupQuotaExceededFault extends __BaseException {
    readonly name: "DBParameterGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBParameterGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>You already have a cluster snapshot with the given identifier.</p>
 * @public
 */
export declare class DBClusterSnapshotAlreadyExistsFault extends __BaseException {
    readonly name: "DBClusterSnapshotAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterSnapshotAlreadyExistsFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBClusterSnapshotIdentifier</code> doesn't refer to an existing cluster snapshot. </p>
 * @public
 */
export declare class DBClusterSnapshotNotFoundFault extends __BaseException {
    readonly name: "DBClusterSnapshotNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterSnapshotNotFoundFault, __BaseException>);
}
/**
 * <p>The provided value isn't a valid cluster snapshot state.</p>
 * @public
 */
export declare class InvalidDBClusterSnapshotStateFault extends __BaseException {
    readonly name: "InvalidDBClusterSnapshotStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterSnapshotStateFault, __BaseException>);
}
/**
 * <p>An error occurred when accessing an KMS key.</p>
 * @public
 */
export declare class KMSKeyNotAccessibleFault extends __BaseException {
    readonly name: "KMSKeyNotAccessibleFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<KMSKeyNotAccessibleFault, __BaseException>);
}
/**
 * <p>The request would cause you to exceed the allowed 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 DBClusterAlreadyExistsFault extends __BaseException {
    readonly name: "DBClusterAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterAlreadyExistsFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBClusterParameterGroupName</code> doesn't refer to an existing cluster parameter group. </p>
 * @public
 */
export declare class DBClusterParameterGroupNotFoundFault extends __BaseException {
    readonly name: "DBClusterParameterGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterParameterGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The cluster can't be created because you have reached the maximum allowed quota of clusters.</p>
 * @public
 */
export declare class DBClusterQuotaExceededFault extends __BaseException {
    readonly name: "DBClusterQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterQuotaExceededFault, __BaseException>);
}
/**
 * <p>Subnets in the subnet group should cover at least two Availability Zones unless there is only one Availability Zone.</p>
 * @public
 */
export declare class DBSubnetGroupDoesNotCoverEnoughAZs extends __BaseException {
    readonly name: "DBSubnetGroupDoesNotCoverEnoughAZs";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupDoesNotCoverEnoughAZs, __BaseException>);
}
/**
 * <p>
 *             <code>DBSubnetGroupName</code> doesn't refer to an existing subnet group. </p>
 * @public
 */
export declare class DBSubnetGroupNotFoundFault extends __BaseException {
    readonly name: "DBSubnetGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The <code>GlobalClusterIdentifier</code> doesn't refer to an existing global cluster.</p>
 * @public
 */
export declare class GlobalClusterNotFoundFault extends __BaseException {
    readonly name: "GlobalClusterNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GlobalClusterNotFoundFault, __BaseException>);
}
/**
 * <p>There is not enough storage available for the current action. You might be able to resolve this error by updating your subnet group to use different Availability Zones that have more storage available. </p>
 * @public
 */
export declare class InsufficientStorageClusterCapacityFault extends __BaseException {
    readonly name: "InsufficientStorageClusterCapacityFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientStorageClusterCapacityFault, __BaseException>);
}
/**
 * <p>The subnet group can't be deleted because it's in use.</p>
 * @public
 */
export declare class InvalidDBSubnetGroupStateFault extends __BaseException {
    readonly name: "InvalidDBSubnetGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBSubnetGroupStateFault, __BaseException>);
}
/**
 * <p>The requested operation can't be performed while the cluster is in this state.</p>
 * @public
 */
export declare class InvalidGlobalClusterStateFault extends __BaseException {
    readonly name: "InvalidGlobalClusterStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidGlobalClusterStateFault, __BaseException>);
}
/**
 * <p>The requested subnet is not valid, or multiple subnets were requested that are not all
 *             in a common virtual private cloud (VPC).</p>
 * @public
 */
export declare class InvalidSubnet extends __BaseException {
    readonly name: "InvalidSubnet";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
}
/**
 * <p>The subnet group doesn't cover all Availability Zones after it is created
 *             because of changes that were made.</p>
 * @public
 */
export declare class InvalidVPCNetworkStateFault extends __BaseException {
    readonly name: "InvalidVPCNetworkStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
}
/**
 * <p>The network type is not supported by either <code>DBSubnetGroup</code> or the DB engine version.</p>
 * @public
 */
export declare class NetworkTypeNotSupported extends __BaseException {
    readonly name: "NetworkTypeNotSupported";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<NetworkTypeNotSupported, __BaseException>);
}
/**
 * <p>The request would cause you to exceed the allowed amount of storage available across
 *             all instances.</p>
 * @public
 */
export declare class StorageQuotaExceededFault extends __BaseException {
    readonly name: "StorageQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<StorageQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified CIDR IP or Amazon EC2 security group isn't authorized for the specified security group.</p>
 *          <p>Amazon DocumentDB also might not be authorized to perform necessary actions on your behalf using IAM.</p>
 * @public
 */
export declare class AuthorizationNotFoundFault extends __BaseException {
    readonly name: "AuthorizationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
}
/**
 * <p>You already have a instance with the given identifier.</p>
 * @public
 */
export declare class DBInstanceAlreadyExistsFault extends __BaseException {
    readonly name: "DBInstanceAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceAlreadyExistsFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBSecurityGroupName</code> doesn't refer to an existing security group. </p>
 * @public
 */
export declare class DBSecurityGroupNotFoundFault extends __BaseException {
    readonly name: "DBSecurityGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The request would cause you to exceed the allowed number of instances.</p>
 * @public
 */
export declare class InstanceQuotaExceededFault extends __BaseException {
    readonly name: "InstanceQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified instance class isn't available in the specified Availability Zone.</p>
 * @public
 */
export declare class InsufficientDBInstanceCapacityFault extends __BaseException {
    readonly name: "InsufficientDBInstanceCapacityFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientDBInstanceCapacityFault, __BaseException>);
}
/**
 * <p>Storage of the specified <code>StorageType</code> can't be associated with the DB
 *             instance. </p>
 * @public
 */
export declare class StorageTypeNotSupportedFault extends __BaseException {
    readonly name: "StorageTypeNotSupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<StorageTypeNotSupportedFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBSubnetGroupName</code> is already being used by an existing subnet group. </p>
 * @public
 */
export declare class DBSubnetGroupAlreadyExistsFault extends __BaseException {
    readonly name: "DBSubnetGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The request would cause you to exceed the allowed number of subnet groups.</p>
 * @public
 */
export declare class DBSubnetGroupQuotaExceededFault extends __BaseException {
    readonly name: "DBSubnetGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The request would cause you to exceed the allowed number of subnets in a subnet group.</p>
 * @public
 */
export declare class DBSubnetQuotaExceededFault extends __BaseException {
    readonly name: "DBSubnetQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetQuotaExceededFault, __BaseException>);
}
/**
 * <p>You have reached the maximum number of event subscriptions. </p>
 * @public
 */
export declare class EventSubscriptionQuotaExceededFault extends __BaseException {
    readonly name: "EventSubscriptionQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
}
/**
 * <p>Amazon SNS has responded that there is a problem with the specified topic. </p>
 * @public
 */
export declare class SNSInvalidTopicFault extends __BaseException {
    readonly name: "SNSInvalidTopicFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
}
/**
 * <p>You do not have permission to publish to the SNS topic Amazon Resource Name (ARN). </p>
 * @public
 */
export declare class SNSNoAuthorizationFault extends __BaseException {
    readonly name: "SNSNoAuthorizationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
}
/**
 * <p>The SNS topic Amazon Resource Name (ARN) does not exist. </p>
 * @public
 */
export declare class SNSTopicArnNotFoundFault extends __BaseException {
    readonly name: "SNSTopicArnNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
}
/**
 * <p>The provided subscription name already exists. </p>
 * @public
 */
export declare class SubscriptionAlreadyExistFault extends __BaseException {
    readonly name: "SubscriptionAlreadyExistFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
}
/**
 * <p>The provided category does not exist. </p>
 * @public
 */
export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
    readonly name: "SubscriptionCategoryNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
}
/**
 * <p>The <code>GlobalClusterIdentifier</code> already exists. Choose a new global cluster identifier (unique name) to create a new global cluster. </p>
 * @public
 */
export declare class GlobalClusterAlreadyExistsFault extends __BaseException {
    readonly name: "GlobalClusterAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GlobalClusterAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The number of global  clusters for this account is already at the maximum allowed.</p>
 * @public
 */
export declare class GlobalClusterQuotaExceededFault extends __BaseException {
    readonly name: "GlobalClusterQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GlobalClusterQuotaExceededFault, __BaseException>);
}
/**
 * <p>The parameter group is in use, or it is in a state that is not valid. If you are trying to delete the parameter group, you can't delete it when the parameter group is in this state.</p>
 * @public
 */
export declare class InvalidDBParameterGroupStateFault extends __BaseException {
    readonly name: "InvalidDBParameterGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBParameterGroupStateFault, __BaseException>);
}
/**
 * <p>
 *             <code>DBSnapshotIdentifier</code> is already being used by an existing snapshot. </p>
 * @public
 */
export declare class DBSnapshotAlreadyExistsFault extends __BaseException {
    readonly name: "DBSnapshotAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSnapshotAlreadyExistsFault, __BaseException>);
}
/**
 * <p> The subnet isn't in the <i>available</i> state. </p>
 * @public
 */
export declare class InvalidDBSubnetStateFault extends __BaseException {
    readonly name: "InvalidDBSubnetStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBSubnetStateFault, __BaseException>);
}
/**
 * <p>Someone else might be modifying a subscription. Wait a few seconds, and try
 *             again.</p>
 * @public
 */
export declare class InvalidEventSubscriptionStateFault extends __BaseException {
    readonly name: "InvalidEventSubscriptionStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEventSubscriptionStateFault, __BaseException>);
}
/**
 * <p>
 *             <code>CertificateIdentifier</code> doesn't refer to an existing certificate. </p>
 * @public
 */
export declare class CertificateNotFoundFault extends __BaseException {
    readonly name: "CertificateNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateNotFoundFault, __BaseException>);
}
/**
 * <p>The state of the security group doesn't allow deletion.</p>
 * @public
 */
export declare class InvalidDBSecurityGroupStateFault extends __BaseException {
    readonly name: "InvalidDBSecurityGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBSecurityGroupStateFault, __BaseException>);
}
/**
 * <p>You have exceeded the maximum number of accounts that you can share a manual DB
 *             snapshot with. </p>
 * @public
 */
export declare class SharedSnapshotQuotaExceededFault extends __BaseException {
    readonly name: "SharedSnapshotQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SharedSnapshotQuotaExceededFault, __BaseException>);
}
/**
 * <p>The upgrade failed because a resource that the depends on can't be
 *             modified.</p>
 * @public
 */
export declare class DBUpgradeDependencyFailureFault extends __BaseException {
    readonly name: "DBUpgradeDependencyFailureFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBUpgradeDependencyFailureFault, __BaseException>);
}
/**
 * <p>The subnet is already in use in the Availability Zone.</p>
 * @public
 */
export declare class SubnetAlreadyInUse extends __BaseException {
    readonly name: "SubnetAlreadyInUse";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubnetAlreadyInUse, __BaseException>);
}
/**
 * <p>The cluster doesn't have enough capacity for the current operation.</p>
 * @public
 */
export declare class InsufficientDBClusterCapacityFault extends __BaseException {
    readonly name: "InsufficientDBClusterCapacityFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientDBClusterCapacityFault, __BaseException>);
}
/**
 * <p>The state of the snapshot doesn't allow deletion.</p>
 * @public
 */
export declare class InvalidDBSnapshotStateFault extends __BaseException {
    readonly name: "InvalidDBSnapshotStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBSnapshotStateFault, __BaseException>);
}
/**
 * <p>You cannot restore from a virtual private cloud (VPC) backup to a non-VPC DB
 *             instance.</p>
 * @public
 */
export declare class InvalidRestoreFault extends __BaseException {
    readonly name: "InvalidRestoreFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRestoreFault, __BaseException>);
}