@aws-sdk/client-neptune 3.933.0 → 3.935.0

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

@@ -0,0 +1,831 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { NeptuneServiceException as __BaseException } from "./NeptuneServiceException";
+/**
+ * <p>
+ *             <i>DBClusterIdentifier</i> does not 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 DB cluster is not in a valid state.</p>
+ * @public
+ */
+export declare class InvalidDBClusterStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterStateFault, __BaseException>);
+}
+/**
+ * <p>The 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 designated subscription could not be found.</p>
+ * @public
+ */
+export declare class SubscriptionNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
+}
+/**
+ * <p>
+ *             <i>DBInstanceIdentifier</i> does not 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>
+ *             <i>DBSnapshotIdentifier</i> does not 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 resource ID was not found.</p>
+ * @public
+ */
+export declare class ResourceNotFoundFault extends __BaseException {
+    readonly name: "ResourceNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
+}
+/**
+ * <p>A 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>
+ *             <i>DBParameterGroupName</i> does not 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>Request would result in 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>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>
+ *             <i>DBClusterSnapshotIdentifier</i> does not 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 is not 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>Error accessing KMS key.</p>
+ * @public
+ */
+export declare class KMSKeyNotAccessibleFault extends __BaseException {
+    readonly name: "KMSKeyNotAccessibleFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<KMSKeyNotAccessibleFault, __BaseException>);
+}
+/**
+ * <p>Request would result in 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>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>
+ *             <i>DBClusterParameterGroupName</i> does not 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>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>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>
+ *             <i>DBSubnetGroupName</i> does not 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>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>There is insufficient storage available for the current action. You may
+ *        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 specified DB instance is not in the <i>available</i> state.</p>
+ * @public
+ */
+export declare class InvalidDBInstanceStateFault extends __BaseException {
+    readonly name: "InvalidDBInstanceStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidDBInstanceStateFault, __BaseException>);
+}
+/**
+ * <p>The DB subnet group cannot be deleted because it is 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>DB subnet group does not cover all Availability Zones after it is created
+ *       because users' change.</p>
+ * @public
+ */
+export declare class InvalidVPCNetworkStateFault extends __BaseException {
+    readonly name: "InvalidVPCNetworkStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
+}
+/**
+ * <p>Request would result in 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>The specified custom endpoint cannot 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>Specified CIDRIP or EC2 security group is not authorized for the specified DB security group.</p>
+ *          <p>Neptune may not also be authorized via IAM to perform necessary actions on your behalf.</p>
+ * @public
+ */
+export declare class AuthorizationNotFoundFault extends __BaseException {
+    readonly name: "AuthorizationNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
+}
+/**
+ * <p>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>
+ *             <i>DBSecurityGroupName</i> does not 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>
+ *             <i>Domain</i> does not 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>Request would result in 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>Specified DB instance class is not 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>The designated 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>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>
+ *             <i>StorageType</i> specified cannot 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>
+ *             <i>DBSubnetGroupName</i> 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>Request would result in 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>Request would result in 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 exceeded the number of events you can subscribe to.</p>
+ * @public
+ */
+export declare class EventSubscriptionQuotaExceededFault extends __BaseException {
+    readonly name: "EventSubscriptionQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>The SNS topic is invalid.</p>
+ * @public
+ */
+export declare class SNSInvalidTopicFault extends __BaseException {
+    readonly name: "SNSInvalidTopicFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
+}
+/**
+ * <p>There is no SNS authorization.</p>
+ * @public
+ */
+export declare class SNSNoAuthorizationFault extends __BaseException {
+    readonly name: "SNSNoAuthorizationFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
+}
+/**
+ * <p>The ARN of the SNS topic could not be found.</p>
+ * @public
+ */
+export declare class SNSTopicArnNotFoundFault extends __BaseException {
+    readonly name: "SNSTopicArnNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
+}
+/**
+ * <p>This subscription already exists.</p>
+ * @public
+ */
+export declare class SubscriptionAlreadyExistFault extends __BaseException {
+    readonly name: "SubscriptionAlreadyExistFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
+}
+/**
+ * <p>The designated subscription category could not be found.</p>
+ * @public
+ */
+export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionCategoryNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
+}
+/**
+ * <p>The <code>GlobalClusterIdentifier</code> already exists. Choose a new global database identifier (unique name) to create a new global database cluster.</p>
+ * @public
+ */
+export declare class GlobalClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "GlobalClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<GlobalClusterAlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>The number of global 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 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 requested operation cannot 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 DB parameter group is in use or is in an invalid state. If you are attempting to
+ *       delete the parameter group, you cannot 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>
+ *             <i>DBSnapshotIdentifier</i> 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 DB subnet is not 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>The event subscription is in an invalid state.</p>
+ * @public
+ */
+export declare class InvalidEventSubscriptionStateFault extends __BaseException {
+    readonly name: "InvalidEventSubscriptionStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidEventSubscriptionStateFault, __BaseException>);
+}
+/**
+ * <p>The state of the DB security group does not allow deletion.</p>
+ * @public
+ */
+export declare class InvalidDBSecurityGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBSecurityGroupStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidDBSecurityGroupStateFault, __BaseException>);
+}
+/**
+ * <p>You have exceeded the maximum number of accounts that you can share a manual DB snapshot with.</p>
+ * @public
+ */
+export declare class SharedSnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SharedSnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SharedSnapshotQuotaExceededFault, __BaseException>);
+}
+/**
+ * <p>
+ *             <i>CertificateIdentifier</i> does not 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 DB upgrade failed because a resource the DB depends on could not 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>The specified IAM role Amazon Resource Name (ARN) is not 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 DB cluster does not have enough capacity for the current operation.</p>
+ * @public
+ */
+export declare class InsufficientDBClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientDBClusterCapacityFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InsufficientDBClusterCapacityFault, __BaseException>);
+}
+/**
+ * <p>The state of the DB snapshot does not allow deletion.</p>
+ * @public
+ */
+export declare class InvalidDBSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidDBSnapshotStateFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidDBSnapshotStateFault, __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>);
+}