@aws-sdk/client-rds 3.933.0 → 3.935.0

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

@@ -0,0 +1,1805 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-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 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>);
+}
+/**
+ * @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>);
+}