import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/core/client";
import { RDSServiceException as __BaseException } from "./RDSServiceException";
/**
 * <p> <code>DBClusterIdentifier</code> doesn't refer to an existing DB cluster.</p>
 * @public
 */
export declare class DBClusterNotFoundFault extends __BaseException {
    readonly name: "DBClusterNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterNotFoundFault, __BaseException>);
}
/**
 * <p>The specified IAM role Amazon Resource Name (ARN) is already associated with the specified DB cluster.</p>
 * @public
 */
export declare class DBClusterRoleAlreadyExistsFault extends __BaseException {
    readonly name: "DBClusterRoleAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterRoleAlreadyExistsFault, __BaseException>);
}
/**
 * <p>You have exceeded the maximum number of IAM roles that can be associated with the specified DB cluster.</p>
 * @public
 */
export declare class DBClusterRoleQuotaExceededFault extends __BaseException {
    readonly name: "DBClusterRoleQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterRoleQuotaExceededFault, __BaseException>);
}
/**
 * <p>The requested operation can't be performed while the cluster is in this state.</p>
 * @public
 */
export declare class InvalidDBClusterStateFault extends __BaseException {
    readonly name: "InvalidDBClusterStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterStateFault, __BaseException>);
}
/**
 * <p> <code>DBInstanceIdentifier</code> doesn't refer to an existing DB instance.</p>
 * @public
 */
export declare class DBInstanceNotFoundFault extends __BaseException {
    readonly name: "DBInstanceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceNotFoundFault, __BaseException>);
}
/**
 * <p>The specified <code>RoleArn</code> or <code>FeatureName</code> value is already associated with the DB instance.</p>
 * @public
 */
export declare class DBInstanceRoleAlreadyExistsFault extends __BaseException {
    readonly name: "DBInstanceRoleAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceRoleAlreadyExistsFault, __BaseException>);
}
/**
 * <p>You can't associate any more Amazon Web Services Identity and Access Management (IAM) roles with the DB instance because the quota has been reached.</p>
 * @public
 */
export declare class DBInstanceRoleQuotaExceededFault extends __BaseException {
    readonly name: "DBInstanceRoleQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceRoleQuotaExceededFault, __BaseException>);
}
/**
 * <p>The DB instance isn't in a valid state.</p>
 * @public
 */
export declare class InvalidDBInstanceStateFault extends __BaseException {
    readonly name: "InvalidDBInstanceStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBInstanceStateFault, __BaseException>);
}
/**
 * <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>BlueGreenDeploymentIdentifier</code> doesn't refer to an existing blue/green deployment.</p>
 * @public
 */
export declare class BlueGreenDeploymentNotFoundFault extends __BaseException {
    readonly name: "BlueGreenDeploymentNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BlueGreenDeploymentNotFoundFault, __BaseException>);
}
/**
 * <p>The DB proxy endpoint doesn't exist.</p>
 * @public
 */
export declare class DBProxyEndpointNotFoundFault extends __BaseException {
    readonly name: "DBProxyEndpointNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyEndpointNotFoundFault, __BaseException>);
}
/**
 * <p>The specified proxy name doesn't correspond to a proxy owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyNotFoundFault extends __BaseException {
    readonly name: "DBProxyNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyNotFoundFault, __BaseException>);
}
/**
 * <p>The specified target group isn't available for a proxy owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyTargetGroupNotFoundFault extends __BaseException {
    readonly name: "DBProxyTargetGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyTargetGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The specified DB shard group name wasn't found.</p>
 * @public
 */
export declare class DBShardGroupNotFoundFault extends __BaseException {
    readonly name: "DBShardGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBShardGroupNotFoundFault, __BaseException>);
}
/**
 * <p> <code>DBSnapshotIdentifier</code> doesn't refer to an existing DB snapshot.</p>
 * @public
 */
export declare class DBSnapshotNotFoundFault extends __BaseException {
    readonly name: "DBSnapshotNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSnapshotNotFoundFault, __BaseException>);
}
/**
 * <p>The specified snapshot tenant database wasn't found.</p>
 * @public
 */
export declare class DBSnapshotTenantDatabaseNotFoundFault extends __BaseException {
    readonly name: "DBSnapshotTenantDatabaseNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSnapshotTenantDatabaseNotFoundFault, __BaseException>);
}
/**
 * <p>The specified integration could not be found.</p>
 * @public
 */
export declare class IntegrationNotFoundFault extends __BaseException {
    readonly name: "IntegrationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationNotFoundFault, __BaseException>);
}
/**
 * <p>The requested operation can't be performed on the endpoint while the endpoint is in this state.</p>
 * @public
 */
export declare class InvalidDBClusterEndpointStateFault extends __BaseException {
    readonly name: "InvalidDBClusterEndpointStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterEndpointStateFault, __BaseException>);
}
/**
 * <p>The specified tenant database wasn't found in the DB instance.</p>
 * @public
 */
export declare class TenantDatabaseNotFoundFault extends __BaseException {
    readonly name: "TenantDatabaseNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TenantDatabaseNotFoundFault, __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>The specified CIDR IP range or Amazon EC2 security group is already authorized for the specified DB security group.</p>
 * @public
 */
export declare class AuthorizationAlreadyExistsFault extends __BaseException {
    readonly name: "AuthorizationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The DB security group authorization quota has been reached.</p>
 * @public
 */
export declare class AuthorizationQuotaExceededFault extends __BaseException {
    readonly name: "AuthorizationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationQuotaExceededFault, __BaseException>);
}
/**
 * <p> <code>DBSecurityGroupName</code> doesn't refer to an existing DB security group.</p>
 * @public
 */
export declare class DBSecurityGroupNotFoundFault extends __BaseException {
    readonly name: "DBSecurityGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The state of the DB 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>The export task doesn't exist.</p>
 * @public
 */
export declare class ExportTaskNotFoundFault extends __BaseException {
    readonly name: "ExportTaskNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ExportTaskNotFoundFault, __BaseException>);
}
/**
 * <p>You can't cancel an export task that has completed.</p>
 * @public
 */
export declare class InvalidExportTaskStateFault extends __BaseException {
    readonly name: "InvalidExportTaskStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidExportTaskStateFault, __BaseException>);
}
/**
 * <p>A DB parameter group with the same name 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 DB parameter group.</p>
 * @public
 */
export declare class DBParameterGroupNotFoundFault extends __BaseException {
    readonly name: "DBParameterGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBParameterGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of DB parameter groups.</p>
 * @public
 */
export declare class DBParameterGroupQuotaExceededFault extends __BaseException {
    readonly name: "DBParameterGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBParameterGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The user already has a DB 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 DB cluster snapshot.</p>
 * @public
 */
export declare class DBClusterSnapshotNotFoundFault extends __BaseException {
    readonly name: "DBClusterSnapshotNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterSnapshotNotFoundFault, __BaseException>);
}
/**
 * <p>The supplied value isn't a valid DB 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 accessing an Amazon Web Services 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 result in the user exceeding the allowed number of DB snapshots.</p>
 * @public
 */
export declare class SnapshotQuotaExceededFault extends __BaseException {
    readonly name: "SnapshotQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SnapshotQuotaExceededFault, __BaseException>);
}
/**
 * <p> <code>CustomAvailabilityZoneId</code> doesn't refer to an existing custom Availability Zone identifier.</p>
 * @public
 */
export declare class CustomAvailabilityZoneNotFoundFault extends __BaseException {
    readonly name: "CustomAvailabilityZoneNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomAvailabilityZoneNotFoundFault, __BaseException>);
}
/**
 * <p> <code>DBSnapshotIdentifier</code> is already 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 state of the DB 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>The option group you are trying to create already exists.</p>
 * @public
 */
export declare class OptionGroupAlreadyExistsFault extends __BaseException {
    readonly name: "OptionGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<OptionGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The specified option group could not be found.</p>
 * @public
 */
export declare class OptionGroupNotFoundFault extends __BaseException {
    readonly name: "OptionGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<OptionGroupNotFoundFault, __BaseException>);
}
/**
 * <p>The quota of 20 option groups was exceeded for this Amazon Web Services account.</p>
 * @public
 */
export declare class OptionGroupQuotaExceededFault extends __BaseException {
    readonly name: "OptionGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<OptionGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>A blue/green deployment with the specified name already exists.</p>
 * @public
 */
export declare class BlueGreenDeploymentAlreadyExistsFault extends __BaseException {
    readonly name: "BlueGreenDeploymentAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BlueGreenDeploymentAlreadyExistsFault, __BaseException>);
}
/**
 * <p> <code>DBClusterParameterGroupName</code> doesn't refer to an existing DB 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 user attempted to create a new DB cluster and the user has already reached the maximum allowed DB cluster quota.</p>
 * @public
 */
export declare class DBClusterQuotaExceededFault extends __BaseException {
    readonly name: "DBClusterQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterQuotaExceededFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of DB instances.</p>
 * @public
 */
export declare class InstanceQuotaExceededFault extends __BaseException {
    readonly name: "InstanceQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceQuotaExceededFault, __BaseException>);
}
/**
 * <p>The source DB cluster isn't supported for a blue/green deployment.</p>
 * @public
 */
export declare class SourceClusterNotSupportedFault extends __BaseException {
    readonly name: "SourceClusterNotSupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SourceClusterNotSupportedFault, __BaseException>);
}
/**
 * <p>The source DB instance isn't supported for a blue/green deployment.</p>
 * @public
 */
export declare class SourceDatabaseNotSupportedFault extends __BaseException {
    readonly name: "SourceDatabaseNotSupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SourceDatabaseNotSupportedFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed amount of storage available across all DB instances.</p>
 * @public
 */
export declare class StorageQuotaExceededFault extends __BaseException {
    readonly name: "StorageQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<StorageQuotaExceededFault, __BaseException>);
}
/**
 * <p>An error occurred while trying to create the CEV.</p>
 * @public
 */
export declare class CreateCustomDBEngineVersionFault extends __BaseException {
    readonly name: "CreateCustomDBEngineVersionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CreateCustomDBEngineVersionFault, __BaseException>);
}
/**
 * <p>A CEV with the specified name already exists.</p>
 * @public
 */
export declare class CustomDBEngineVersionAlreadyExistsFault extends __BaseException {
    readonly name: "CustomDBEngineVersionAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The specified CEV was not found.</p>
 * @public
 */
export declare class CustomDBEngineVersionNotFoundFault extends __BaseException {
    readonly name: "CustomDBEngineVersionNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionNotFoundFault, __BaseException>);
}
/**
 * <p>You have exceeded your CEV quota.</p>
 * @public
 */
export declare class CustomDBEngineVersionQuotaExceededFault extends __BaseException {
    readonly name: "CustomDBEngineVersionQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionQuotaExceededFault, __BaseException>);
}
/**
 * <p>The AMI configuration prerequisite has not been met.</p>
 * @public
 */
export declare class Ec2ImagePropertiesNotSupportedFault extends __BaseException {
    readonly name: "Ec2ImagePropertiesNotSupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<Ec2ImagePropertiesNotSupportedFault, __BaseException>);
}
/**
 * <p>You can't delete the CEV.</p>
 * @public
 */
export declare class InvalidCustomDBEngineVersionStateFault extends __BaseException {
    readonly name: "InvalidCustomDBEngineVersionStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidCustomDBEngineVersionStateFault, __BaseException>);
}
/**
 * <p>The user already has a DB 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>Subnets in the DB 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 DB subnet group.</p>
 * @public
 */
export declare class DBSubnetGroupNotFoundFault extends __BaseException {
    readonly name: "DBSubnetGroupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotFoundFault, __BaseException>);
}
/**
 * <p> <code>Domain</code> doesn't refer to an existing Active Directory domain.</p>
 * @public
 */
export declare class DomainNotFoundFault extends __BaseException {
    readonly name: "DomainNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DomainNotFoundFault, __BaseException>);
}
/**
 * <p>The <code>GlobalClusterIdentifier</code> doesn't refer to an existing global database cluster.</p>
 * @public
 */
export declare class GlobalClusterNotFoundFault extends __BaseException {
    readonly name: "GlobalClusterNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GlobalClusterNotFoundFault, __BaseException>);
}
/**
 * <p>The specified DB 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>There is insufficient 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 DBSubnetGroup doesn't belong to the same VPC as that of an existing cross-region read replica of the same source instance.</p>
 * @public
 */
export declare class InvalidDBSubnetGroupFault extends __BaseException {
    readonly name: "InvalidDBSubnetGroupFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBSubnetGroupFault, __BaseException>);
}
/**
 * <p>The DB subnet group cannot 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 global cluster is in an invalid state and can't perform the requested operation.</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 invalid, or multiple subnets were requested that are not all in a common VPC.</p>
 * @public
 */
export declare class InvalidSubnet extends __BaseException {
    readonly name: "InvalidSubnet";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
}
/**
 * <p>The DB subnet group doesn't cover all Availability Zones after it's created because of users' change.</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 invalid for the DB instance. Valid nework type values are <code>IPV4</code> and <code>DUAL</code>.</p>
 * @public
 */
export declare class NetworkTypeNotSupported extends __BaseException {
    readonly name: "NetworkTypeNotSupported";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<NetworkTypeNotSupported, __BaseException>);
}
/**
 * <p>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>The operation violates VPC encryption control settings. Make sure that your DB instance type supports the Nitro encryption-in-transit capability, or modify your VPC's encryption controls to not enforce encryption-in-transit.</p>
 * @public
 */
export declare class VpcEncryptionControlViolationException extends __BaseException {
    readonly name: "VpcEncryptionControlViolationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<VpcEncryptionControlViolationException, __BaseException>);
}
/**
 * <p>The specified custom endpoint can't be created because it already exists.</p>
 * @public
 */
export declare class DBClusterEndpointAlreadyExistsFault extends __BaseException {
    readonly name: "DBClusterEndpointAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterEndpointAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The cluster already has the maximum number of custom endpoints.</p>
 * @public
 */
export declare class DBClusterEndpointQuotaExceededFault extends __BaseException {
    readonly name: "DBClusterEndpointQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterEndpointQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified CIDR IP range or Amazon EC2 security group might not be authorized for the specified DB security group.</p> <p>Or, RDS might not be authorized to perform necessary actions using IAM on your behalf.</p>
 * @public
 */
export declare class AuthorizationNotFoundFault extends __BaseException {
    readonly name: "AuthorizationNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
}
/**
 * <p/>
 *
 * @deprecated Please avoid using this fault.
 * @public
 */
export declare class BackupPolicyNotFoundFault extends __BaseException {
    readonly name: "BackupPolicyNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BackupPolicyNotFoundFault, __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 user already has a DB 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>Provisioned IOPS not available in the specified Availability Zone.</p>
 * @public
 */
export declare class ProvisionedIopsNotAvailableInAZFault extends __BaseException {
    readonly name: "ProvisionedIopsNotAvailableInAZFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ProvisionedIopsNotAvailableInAZFault, __BaseException>);
}
/**
 * <p>You attempted to create more tenant databases than are permitted in your Amazon Web Services account.</p>
 * @public
 */
export declare class TenantDatabaseQuotaExceededFault extends __BaseException {
    readonly name: "TenantDatabaseQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TenantDatabaseQuotaExceededFault, __BaseException>);
}
/**
 * <p>The DBSubnetGroup shouldn't be specified while creating read replicas that lie in the same region as the source instance.</p>
 * @public
 */
export declare class DBSubnetGroupNotAllowedFault extends __BaseException {
    readonly name: "DBSubnetGroupNotAllowedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotAllowedFault, __BaseException>);
}
/**
 * <p>The specified proxy name must be unique for all proxies owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyAlreadyExistsFault extends __BaseException {
    readonly name: "DBProxyAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyAlreadyExistsFault, __BaseException>);
}
/**
 * <p>Your Amazon Web Services account already has the maximum number of proxies in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyQuotaExceededFault extends __BaseException {
    readonly name: "DBProxyQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified DB proxy endpoint name must be unique for all DB proxy endpoints owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyEndpointAlreadyExistsFault extends __BaseException {
    readonly name: "DBProxyEndpointAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyEndpointAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The DB proxy already has the maximum number of endpoints.</p>
 * @public
 */
export declare class DBProxyEndpointQuotaExceededFault extends __BaseException {
    readonly name: "DBProxyEndpointQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyEndpointQuotaExceededFault, __BaseException>);
}
/**
 * <p>The requested operation can't be performed while the proxy is in this state.</p>
 * @public
 */
export declare class InvalidDBProxyStateFault extends __BaseException {
    readonly name: "InvalidDBProxyStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBProxyStateFault, __BaseException>);
}
/**
 * <p>A DB security group with the name specified in <code>DBSecurityGroupName</code> already exists.</p>
 * @public
 */
export declare class DBSecurityGroupAlreadyExistsFault extends __BaseException {
    readonly name: "DBSecurityGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSecurityGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>A DB security group isn't allowed for this action.</p>
 * @public
 */
export declare class DBSecurityGroupNotSupportedFault extends __BaseException {
    readonly name: "DBSecurityGroupNotSupportedFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotSupportedFault, __BaseException>);
}
/**
 * <p>The request would result in the user exceeding the allowed number of DB security groups.</p>
 * @public
 */
export declare class DBSecurityGroupQuotaExceededFault extends __BaseException {
    readonly name: "DBSecurityGroupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBSecurityGroupQuotaExceededFault, __BaseException>);
}
/**
 * <p>The specified DB shard group name must be unique in your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBShardGroupAlreadyExistsFault extends __BaseException {
    readonly name: "DBShardGroupAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBShardGroupAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The maximum number of DB shard groups for your Amazon Web Services account in the specified Amazon Web Services Region has been reached.</p>
 * @public
 */
export declare class MaxDBShardGroupLimitReached extends __BaseException {
    readonly name: "MaxDBShardGroupLimitReached";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<MaxDBShardGroupLimitReached, __BaseException>);
}
/**
 * <p>The specified DB engine version isn't supported for Aurora Limitless Database.</p>
 * @public
 */
export declare class UnsupportedDBEngineVersionFault extends __BaseException {
    readonly name: "UnsupportedDBEngineVersionFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnsupportedDBEngineVersionFault, __BaseException>);
}
/**
 * <p> <code>DBSubnetGroupName</code> is already used by an existing DB 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 result in the user exceeding the allowed number of DB 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 result in the user exceeding the allowed number of subnets in a DB subnet groups.</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>SNS has responded that there is a problem with the SNS topic specified.</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 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 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 supplied 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 supplied 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. Specify a new global database identifier (unique name) to create a new global database cluster or to rename an existing one.</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 database 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 DB shard group must be in the available state.</p>
 * @public
 */
export declare class InvalidDBShardGroupStateFault extends __BaseException {
    readonly name: "InvalidDBShardGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBShardGroupStateFault, __BaseException>);
}
/**
 * <p>The integration you are trying to create already exists.</p>
 * @public
 */
export declare class IntegrationAlreadyExistsFault extends __BaseException {
    readonly name: "IntegrationAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationAlreadyExistsFault, __BaseException>);
}
/**
 * <p>A conflicting conditional operation is currently in progress against this resource. Typically occurs when there are multiple requests being made to the same resource at the same time, and these requests conflict with each other.</p>
 * @public
 */
export declare class IntegrationConflictOperationFault extends __BaseException {
    readonly name: "IntegrationConflictOperationFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationConflictOperationFault, __BaseException>);
}
/**
 * <p>You can't crate any more zero-ETL integrations because the quota has been reached.</p>
 * @public
 */
export declare class IntegrationQuotaExceededFault extends __BaseException {
    readonly name: "IntegrationQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IntegrationQuotaExceededFault, __BaseException>);
}
/**
 * <p>You attempted to either create a tenant database that already exists or modify a tenant database to use the name of an existing tenant database.</p>
 * @public
 */
export declare class TenantDatabaseAlreadyExistsFault extends __BaseException {
    readonly name: "TenantDatabaseAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TenantDatabaseAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The blue/green deployment can't be switched over or deleted because there is an invalid configuration in the green environment.</p>
 * @public
 */
export declare class InvalidBlueGreenDeploymentStateFault extends __BaseException {
    readonly name: "InvalidBlueGreenDeploymentStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidBlueGreenDeploymentStateFault, __BaseException>);
}
/**
 * <p>The quota for retained automated backups was exceeded. This prevents you from retaining any additional automated backups. The retained automated backups quota is the same as your DB cluster quota.</p>
 * @public
 */
export declare class DBClusterAutomatedBackupQuotaExceededFault extends __BaseException {
    readonly name: "DBClusterAutomatedBackupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterAutomatedBackupQuotaExceededFault, __BaseException>);
}
/**
 * <p>No automated backup for this DB cluster was found.</p>
 * @public
 */
export declare class DBClusterAutomatedBackupNotFoundFault extends __BaseException {
    readonly name: "DBClusterAutomatedBackupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterAutomatedBackupNotFoundFault, __BaseException>);
}
/**
 * <p>The automated backup is in an invalid state. For example, this automated backup is associated with an active cluster.</p>
 * @public
 */
export declare class InvalidDBClusterAutomatedBackupStateFault extends __BaseException {
    readonly name: "InvalidDBClusterAutomatedBackupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterAutomatedBackupStateFault, __BaseException>);
}
/**
 * <p>The specified custom endpoint doesn't exist.</p>
 * @public
 */
export declare class DBClusterEndpointNotFoundFault extends __BaseException {
    readonly name: "DBClusterEndpointNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterEndpointNotFoundFault, __BaseException>);
}
/**
 * <p>The DB parameter group is in use or is in an invalid state. If you are attempting 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>The quota for retained automated backups was exceeded. This prevents you from retaining any additional automated backups. The retained automated backups quota is the same as your DB instance quota.</p>
 * @public
 */
export declare class DBInstanceAutomatedBackupQuotaExceededFault extends __BaseException {
    readonly name: "DBInstanceAutomatedBackupQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceAutomatedBackupQuotaExceededFault, __BaseException>);
}
/**
 * <p>No automated backup for this DB instance was found.</p>
 * @public
 */
export declare class DBInstanceAutomatedBackupNotFoundFault extends __BaseException {
    readonly name: "DBInstanceAutomatedBackupNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceAutomatedBackupNotFoundFault, __BaseException>);
}
/**
 * <p>The automated backup is in an invalid state. For example, this automated backup is associated with an active instance.</p>
 * @public
 */
export declare class InvalidDBInstanceAutomatedBackupStateFault extends __BaseException {
    readonly name: "InvalidDBInstanceAutomatedBackupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBInstanceAutomatedBackupStateFault, __BaseException>);
}
/**
 * <p>You can't perform this operation while the DB proxy endpoint is in a particular state.</p>
 * @public
 */
export declare class InvalidDBProxyEndpointStateFault extends __BaseException {
    readonly name: "InvalidDBProxyEndpointStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBProxyEndpointStateFault, __BaseException>);
}
/**
 * <p>The DB 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>This error can occur if someone else is modifying a subscription. You should retry the action.</p>
 * @public
 */
export declare class InvalidEventSubscriptionStateFault extends __BaseException {
    readonly name: "InvalidEventSubscriptionStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEventSubscriptionStateFault, __BaseException>);
}
/**
 * <p>The integration is in an invalid state and can't perform the requested operation.</p>
 * @public
 */
export declare class InvalidIntegrationStateFault extends __BaseException {
    readonly name: "InvalidIntegrationStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidIntegrationStateFault, __BaseException>);
}
/**
 * <p>The option group isn't in the <i>available</i> state.</p>
 * @public
 */
export declare class InvalidOptionGroupStateFault extends __BaseException {
    readonly name: "InvalidOptionGroupStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidOptionGroupStateFault, __BaseException>);
}
/**
 * <p>The specified RDS DB instance or Aurora DB cluster isn't available for a proxy owned by your Amazon Web Services account in the specified Amazon Web Services Region.</p>
 * @public
 */
export declare class DBProxyTargetNotFoundFault extends __BaseException {
    readonly name: "DBProxyTargetNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyTargetNotFoundFault, __BaseException>);
}
/**
 * <p> <code>BacktrackIdentifier</code> doesn't refer to an existing backtrack.</p>
 * @public
 */
export declare class DBClusterBacktrackNotFoundFault extends __BaseException {
    readonly name: "DBClusterBacktrackNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterBacktrackNotFoundFault, __BaseException>);
}
/**
 * <p>An attempt to download or examine log files didn't succeed because an Aurora Serverless v2 instance was paused.</p>
 * @public
 */
export declare class DBInstanceNotReadyFault extends __BaseException {
    readonly name: "DBInstanceNotReadyFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceNotReadyFault, __BaseException>);
}
/**
 * <p>The specified reserved DB Instance not found.</p>
 * @public
 */
export declare class ReservedDBInstanceNotFoundFault extends __BaseException {
    readonly name: "ReservedDBInstanceNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedDBInstanceNotFoundFault, __BaseException>);
}
/**
 * <p>Specified offering does not exist.</p>
 * @public
 */
export declare class ReservedDBInstancesOfferingNotFoundFault extends __BaseException {
    readonly name: "ReservedDBInstancesOfferingNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedDBInstancesOfferingNotFoundFault, __BaseException>);
}
/**
 * <p>The operation can't be performed because another operation is in progress.</p>
 * @public
 */
export declare class InvalidResourceStateFault extends __BaseException {
    readonly name: "InvalidResourceStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidResourceStateFault, __BaseException>);
}
/**
 * <p> <code>LogFileName</code> doesn't refer to an existing DB log file.</p>
 * @public
 */
export declare class DBLogFileNotFoundFault extends __BaseException {
    readonly name: "DBLogFileNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBLogFileNotFoundFault, __BaseException>);
}
/**
 * <p> <code>Capacity</code> isn't a valid Aurora Serverless DB cluster capacity. Valid capacity values are <code>2</code>, <code>4</code>, <code>8</code>, <code>16</code>, <code>32</code>, <code>64</code>, <code>128</code>, and <code>256</code>.</p>
 * @public
 */
export declare class InvalidDBClusterCapacityFault extends __BaseException {
    readonly name: "InvalidDBClusterCapacityFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDBClusterCapacityFault, __BaseException>);
}
/**
 * <p>The <code>aurora-iopt1</code> storage type isn't available, because you modified the DB cluster to use this storage type less than one month ago.</p>
 * @public
 */
export declare class StorageTypeNotAvailableFault extends __BaseException {
    readonly name: "StorageTypeNotAvailableFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<StorageTypeNotAvailableFault, __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 DB upgrade failed because a resource the DB 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 DB 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>User already has a reservation with the given identifier.</p>
 * @public
 */
export declare class ReservedDBInstanceAlreadyExistsFault extends __BaseException {
    readonly name: "ReservedDBInstanceAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedDBInstanceAlreadyExistsFault, __BaseException>);
}
/**
 * <p>Request would exceed the user's DB Instance quota.</p>
 * @public
 */
export declare class ReservedDBInstanceQuotaExceededFault extends __BaseException {
    readonly name: "ReservedDBInstanceQuotaExceededFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ReservedDBInstanceQuotaExceededFault, __BaseException>);
}
/**
 * <p>The proxy is already associated with the specified RDS DB instance or Aurora DB cluster.</p>
 * @public
 */
export declare class DBProxyTargetAlreadyRegisteredFault extends __BaseException {
    readonly name: "DBProxyTargetAlreadyRegisteredFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBProxyTargetAlreadyRegisteredFault, __BaseException>);
}
/**
 * <p>The requested operation can't be performed because there aren't enough available IP addresses in the proxy's subnets. Add more CIDR blocks to the VPC or remove IP address that aren't required from the subnets.</p>
 * @public
 */
export declare class InsufficientAvailableIPsInSubnetFault extends __BaseException {
    readonly name: "InsufficientAvailableIPsInSubnetFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientAvailableIPsInSubnetFault, __BaseException>);
}
/**
 * <p>The specified IAM role Amazon Resource Name (ARN) isn't associated with the specified DB cluster.</p>
 * @public
 */
export declare class DBClusterRoleNotFoundFault extends __BaseException {
    readonly name: "DBClusterRoleNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBClusterRoleNotFoundFault, __BaseException>);
}
/**
 * <p>The specified <code>RoleArn</code> value doesn't match the specified feature for the DB instance.</p>
 * @public
 */
export declare class DBInstanceRoleNotFoundFault extends __BaseException {
    readonly name: "DBInstanceRoleNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DBInstanceRoleNotFoundFault, __BaseException>);
}
/**
 * <p>The specified Amazon S3 bucket name can't be found or Amazon RDS isn't authorized to access the specified Amazon S3 bucket. Verify the <b>SourceS3BucketName</b> and <b>S3IngestionRoleArn</b> values and try again.</p>
 * @public
 */
export declare class InvalidS3BucketFault extends __BaseException {
    readonly name: "InvalidS3BucketFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidS3BucketFault, __BaseException>);
}
/**
 * <p>The DB 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>Cannot restore from VPC backup to non-VPC DB instance.</p>
 * @public
 */
export declare class InvalidRestoreFault extends __BaseException {
    readonly name: "InvalidRestoreFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRestoreFault, __BaseException>);
}
/**
 * <p> <code>SourceDBInstanceIdentifier</code> refers to a DB instance with <code>BackupRetentionPeriod</code> equal to 0.</p>
 * @public
 */
export declare class PointInTimeRestoreNotEnabledFault extends __BaseException {
    readonly name: "PointInTimeRestoreNotEnabledFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PointInTimeRestoreNotEnabledFault, __BaseException>);
}
/**
 * <p>You can't start an export task that's already running.</p>
 * @public
 */
export declare class ExportTaskAlreadyExistsFault extends __BaseException {
    readonly name: "ExportTaskAlreadyExistsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ExportTaskAlreadyExistsFault, __BaseException>);
}
/**
 * <p>The IAM role requires additional permissions to export to an Amazon S3 bucket.</p>
 * @public
 */
export declare class IamRoleMissingPermissionsFault extends __BaseException {
    readonly name: "IamRoleMissingPermissionsFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamRoleMissingPermissionsFault, __BaseException>);
}
/**
 * <p>The IAM role is missing for exporting to an Amazon S3 bucket.</p>
 * @public
 */
export declare class IamRoleNotFoundFault extends __BaseException {
    readonly name: "IamRoleNotFoundFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamRoleNotFoundFault, __BaseException>);
}
/**
 * <p>The export is invalid for exporting to an Amazon S3 bucket.</p>
 * @public
 */
export declare class InvalidExportOnlyFault extends __BaseException {
    readonly name: "InvalidExportOnlyFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidExportOnlyFault, __BaseException>);
}
/**
 * <p>The state of the export snapshot is invalid for exporting to an Amazon S3 bucket.</p>
 * @public
 */
export declare class InvalidExportSourceStateFault extends __BaseException {
    readonly name: "InvalidExportSourceStateFault";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidExportSourceStateFault, __BaseException>);
}