@aws-sdk/client-docdb 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2302 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { DocDBServiceException as __BaseException } from "./DocDBServiceException";
+
+export interface AddSourceIdentifierToSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SourceIdentifier: string | undefined;
+}
+export declare namespace AddSourceIdentifierToSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: AddSourceIdentifierToSubscriptionMessage) => any;
+}
+
+export interface EventSubscription {
+    
+    CustomerAwsId?: string;
+    
+    CustSubscriptionId?: string;
+    
+    SnsTopicArn?: string;
+    
+    Status?: string;
+    
+    SubscriptionCreationTime?: string;
+    
+    SourceType?: string;
+    
+    SourceIdsList?: string[];
+    
+    EventCategoriesList?: string[];
+    
+    Enabled?: boolean;
+    
+    EventSubscriptionArn?: string;
+}
+export declare namespace EventSubscription {
+    
+    const filterSensitiveLog: (obj: EventSubscription) => any;
+}
+export interface AddSourceIdentifierToSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace AddSourceIdentifierToSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: AddSourceIdentifierToSubscriptionResult) => any;
+}
+
+export declare class SourceNotFoundFault extends __BaseException {
+    readonly name: "SourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsToResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace AddTagsToResourceMessage {
+    
+    const filterSensitiveLog: (obj: AddTagsToResourceMessage) => any;
+}
+
+export declare class DBClusterNotFoundFault extends __BaseException {
+    readonly name: "DBClusterNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterNotFoundFault, __BaseException>);
+}
+
+export declare class DBInstanceNotFoundFault extends __BaseException {
+    readonly name: "DBInstanceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceNotFoundFault, __BaseException>);
+}
+
+export declare class DBSnapshotNotFoundFault extends __BaseException {
+    readonly name: "DBSnapshotNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSnapshotNotFoundFault, __BaseException>);
+}
+
+export interface ApplyPendingMaintenanceActionMessage {
+    
+    ResourceIdentifier: string | undefined;
+    
+    ApplyAction: string | undefined;
+    
+    OptInType: string | undefined;
+}
+export declare namespace ApplyPendingMaintenanceActionMessage {
+    
+    const filterSensitiveLog: (obj: ApplyPendingMaintenanceActionMessage) => any;
+}
+
+export interface PendingMaintenanceAction {
+    
+    Action?: string;
+    
+    AutoAppliedAfterDate?: Date;
+    
+    ForcedApplyDate?: Date;
+    
+    OptInStatus?: string;
+    
+    CurrentApplyDate?: Date;
+    
+    Description?: string;
+}
+export declare namespace PendingMaintenanceAction {
+    
+    const filterSensitiveLog: (obj: PendingMaintenanceAction) => any;
+}
+
+export interface ResourcePendingMaintenanceActions {
+    
+    ResourceIdentifier?: string;
+    
+    PendingMaintenanceActionDetails?: PendingMaintenanceAction[];
+}
+export declare namespace ResourcePendingMaintenanceActions {
+    
+    const filterSensitiveLog: (obj: ResourcePendingMaintenanceActions) => any;
+}
+export interface ApplyPendingMaintenanceActionResult {
+    
+    ResourcePendingMaintenanceActions?: ResourcePendingMaintenanceActions;
+}
+export declare namespace ApplyPendingMaintenanceActionResult {
+    
+    const filterSensitiveLog: (obj: ApplyPendingMaintenanceActionResult) => any;
+}
+
+export declare class InvalidDBClusterStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterStateFault, __BaseException>);
+}
+
+export declare class InvalidDBInstanceStateFault extends __BaseException {
+    readonly name: "InvalidDBInstanceStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBInstanceStateFault, __BaseException>);
+}
+
+export declare class ResourceNotFoundFault extends __BaseException {
+    readonly name: "ResourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
+}
+
+export interface CopyDBClusterParameterGroupMessage {
+    
+    SourceDBClusterParameterGroupIdentifier: string | undefined;
+    
+    TargetDBClusterParameterGroupIdentifier: string | undefined;
+    
+    TargetDBClusterParameterGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterParameterGroupMessage) => any;
+}
+
+export interface DBClusterParameterGroup {
+    
+    DBClusterParameterGroupName?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    Description?: string;
+    
+    DBClusterParameterGroupArn?: string;
+}
+export declare namespace DBClusterParameterGroup {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroup) => any;
+}
+export interface CopyDBClusterParameterGroupResult {
+    
+    DBClusterParameterGroup?: DBClusterParameterGroup;
+}
+export declare namespace CopyDBClusterParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterParameterGroupResult) => any;
+}
+
+export declare class DBParameterGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "DBParameterGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "DBParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DBParameterGroupQuotaExceededFault extends __BaseException {
+    readonly name: "DBParameterGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupQuotaExceededFault, __BaseException>);
+}
+
+export interface CopyDBClusterSnapshotMessage {
+    
+    SourceDBClusterSnapshotIdentifier: string | undefined;
+    
+    TargetDBClusterSnapshotIdentifier: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+    
+    CopyTags?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterSnapshotMessage) => any;
+}
+
+export interface DBClusterSnapshot {
+    
+    AvailabilityZones?: string[];
+    
+    DBClusterSnapshotIdentifier?: string;
+    
+    DBClusterIdentifier?: string;
+    
+    SnapshotCreateTime?: Date;
+    
+    Engine?: string;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    VpcId?: string;
+    
+    ClusterCreateTime?: Date;
+    
+    MasterUsername?: string;
+    
+    EngineVersion?: string;
+    
+    SnapshotType?: string;
+    
+    PercentProgress?: number;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DBClusterSnapshotArn?: string;
+    
+    SourceDBClusterSnapshotArn?: string;
+}
+export declare namespace DBClusterSnapshot {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshot) => any;
+}
+export interface CopyDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace CopyDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterSnapshotResult) => any;
+}
+
+export declare class DBClusterSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterSnapshotAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterSnapshotNotFoundFault extends __BaseException {
+    readonly name: "DBClusterSnapshotNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterSnapshotNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidDBClusterSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterSnapshotStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterSnapshotStateFault, __BaseException>);
+}
+
+export declare class KMSKeyNotAccessibleFault extends __BaseException {
+    readonly name: "KMSKeyNotAccessibleFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSKeyNotAccessibleFault, __BaseException>);
+}
+
+export declare class SnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateDBClusterMessage {
+    
+    AvailabilityZones?: string[];
+    
+    BackupRetentionPeriod?: number;
+    
+    DBClusterIdentifier: string | undefined;
+    
+    DBClusterParameterGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    DBSubnetGroupName?: string;
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    Port?: number;
+    
+    MasterUsername?: string;
+    
+    MasterUserPassword?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    Tags?: Tag[];
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    DeletionProtection?: boolean;
+    
+    GlobalClusterIdentifier?: string;
+}
+export declare namespace CreateDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterMessage) => any;
+}
+
+export interface DBClusterRole {
+    
+    RoleArn?: string;
+    
+    Status?: string;
+}
+export declare namespace DBClusterRole {
+    
+    const filterSensitiveLog: (obj: DBClusterRole) => any;
+}
+
+export interface DBClusterMember {
+    
+    DBInstanceIdentifier?: string;
+    
+    IsClusterWriter?: boolean;
+    
+    DBClusterParameterGroupStatus?: string;
+    
+    PromotionTier?: number;
+}
+export declare namespace DBClusterMember {
+    
+    const filterSensitiveLog: (obj: DBClusterMember) => any;
+}
+
+export interface VpcSecurityGroupMembership {
+    
+    VpcSecurityGroupId?: string;
+    
+    Status?: string;
+}
+export declare namespace VpcSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: VpcSecurityGroupMembership) => any;
+}
+
+export interface DBCluster {
+    
+    AvailabilityZones?: string[];
+    
+    BackupRetentionPeriod?: number;
+    
+    DBClusterIdentifier?: string;
+    
+    DBClusterParameterGroup?: string;
+    
+    DBSubnetGroup?: string;
+    
+    Status?: string;
+    
+    PercentProgress?: string;
+    
+    EarliestRestorableTime?: Date;
+    
+    Endpoint?: string;
+    
+    ReaderEndpoint?: string;
+    
+    MultiAZ?: boolean;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    LatestRestorableTime?: Date;
+    
+    Port?: number;
+    
+    MasterUsername?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    ReplicationSourceIdentifier?: string;
+    
+    ReadReplicaIdentifiers?: string[];
+    
+    DBClusterMembers?: DBClusterMember[];
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    HostedZoneId?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DbClusterResourceId?: string;
+    
+    DBClusterArn?: string;
+    
+    AssociatedRoles?: DBClusterRole[];
+    
+    ClusterCreateTime?: Date;
+    
+    EnabledCloudwatchLogsExports?: string[];
+    
+    DeletionProtection?: boolean;
+}
+export declare namespace DBCluster {
+    
+    const filterSensitiveLog: (obj: DBCluster) => any;
+}
+export interface CreateDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace CreateDBClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterResult) => any;
+}
+
+export declare class DBClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "DBClusterParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterParameterGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DBClusterQuotaExceededFault extends __BaseException {
+    readonly name: "DBClusterQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBSubnetGroupDoesNotCoverEnoughAZs extends __BaseException {
+    readonly name: "DBSubnetGroupDoesNotCoverEnoughAZs";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupDoesNotCoverEnoughAZs, __BaseException>);
+}
+
+export declare class DBSubnetGroupNotFoundFault extends __BaseException {
+    readonly name: "DBSubnetGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotFoundFault, __BaseException>);
+}
+
+export declare class GlobalClusterNotFoundFault extends __BaseException {
+    readonly name: "GlobalClusterNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterNotFoundFault, __BaseException>);
+}
+
+export declare class InsufficientStorageClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientStorageClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientStorageClusterCapacityFault, __BaseException>);
+}
+
+export declare class InvalidDBSubnetGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBSubnetGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSubnetGroupStateFault, __BaseException>);
+}
+
+export declare class InvalidGlobalClusterStateFault extends __BaseException {
+    readonly name: "InvalidGlobalClusterStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidGlobalClusterStateFault, __BaseException>);
+}
+
+export declare class InvalidSubnet extends __BaseException {
+    readonly name: "InvalidSubnet";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
+}
+
+export declare class InvalidVPCNetworkStateFault extends __BaseException {
+    readonly name: "InvalidVPCNetworkStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
+}
+
+export declare class StorageQuotaExceededFault extends __BaseException {
+    readonly name: "StorageQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<StorageQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Description: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterParameterGroupMessage) => any;
+}
+export interface CreateDBClusterParameterGroupResult {
+    
+    DBClusterParameterGroup?: DBClusterParameterGroup;
+}
+export declare namespace CreateDBClusterParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterParameterGroupResult) => any;
+}
+
+export interface CreateDBClusterSnapshotMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+    
+    DBClusterIdentifier: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterSnapshotMessage) => any;
+}
+export interface CreateDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace CreateDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterSnapshotResult) => any;
+}
+
+export declare class AuthorizationNotFoundFault extends __BaseException {
+    readonly name: "AuthorizationNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
+}
+
+export interface CreateDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    DBInstanceClass: string | undefined;
+    
+    Engine: string | undefined;
+    
+    AvailabilityZone?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    Tags?: Tag[];
+    
+    DBClusterIdentifier: string | undefined;
+    
+    PromotionTier?: number;
+}
+export declare namespace CreateDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceMessage) => any;
+}
+
+export interface AvailabilityZone {
+    
+    Name?: string;
+}
+export declare namespace AvailabilityZone {
+    
+    const filterSensitiveLog: (obj: AvailabilityZone) => any;
+}
+
+export interface Subnet {
+    
+    SubnetIdentifier?: string;
+    
+    SubnetAvailabilityZone?: AvailabilityZone;
+    
+    SubnetStatus?: string;
+}
+export declare namespace Subnet {
+    
+    const filterSensitiveLog: (obj: Subnet) => any;
+}
+
+export interface DBSubnetGroup {
+    
+    DBSubnetGroupName?: string;
+    
+    DBSubnetGroupDescription?: string;
+    
+    VpcId?: string;
+    
+    SubnetGroupStatus?: string;
+    
+    Subnets?: Subnet[];
+    
+    DBSubnetGroupArn?: string;
+}
+export declare namespace DBSubnetGroup {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroup) => any;
+}
+
+export interface Endpoint {
+    
+    Address?: string;
+    
+    Port?: number;
+    
+    HostedZoneId?: string;
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+
+export interface PendingCloudwatchLogsExports {
+    
+    LogTypesToEnable?: string[];
+    
+    LogTypesToDisable?: string[];
+}
+export declare namespace PendingCloudwatchLogsExports {
+    
+    const filterSensitiveLog: (obj: PendingCloudwatchLogsExports) => any;
+}
+
+export interface PendingModifiedValues {
+    
+    DBInstanceClass?: string;
+    
+    AllocatedStorage?: number;
+    
+    MasterUserPassword?: string;
+    
+    Port?: number;
+    
+    BackupRetentionPeriod?: number;
+    
+    MultiAZ?: boolean;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    DBInstanceIdentifier?: string;
+    
+    StorageType?: string;
+    
+    CACertificateIdentifier?: string;
+    
+    DBSubnetGroupName?: string;
+    
+    PendingCloudwatchLogsExports?: PendingCloudwatchLogsExports;
+}
+export declare namespace PendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: PendingModifiedValues) => any;
+}
+
+export interface DBInstanceStatusInfo {
+    
+    StatusType?: string;
+    
+    Normal?: boolean;
+    
+    Status?: string;
+    
+    Message?: string;
+}
+export declare namespace DBInstanceStatusInfo {
+    
+    const filterSensitiveLog: (obj: DBInstanceStatusInfo) => any;
+}
+
+export interface DBInstance {
+    
+    DBInstanceIdentifier?: string;
+    
+    DBInstanceClass?: string;
+    
+    Engine?: string;
+    
+    DBInstanceStatus?: string;
+    
+    Endpoint?: Endpoint;
+    
+    InstanceCreateTime?: Date;
+    
+    PreferredBackupWindow?: string;
+    
+    BackupRetentionPeriod?: number;
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    AvailabilityZone?: string;
+    
+    DBSubnetGroup?: DBSubnetGroup;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    PendingModifiedValues?: PendingModifiedValues;
+    
+    LatestRestorableTime?: Date;
+    
+    EngineVersion?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    PubliclyAccessible?: boolean;
+    
+    StatusInfos?: DBInstanceStatusInfo[];
+    
+    DBClusterIdentifier?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DbiResourceId?: string;
+    
+    CACertificateIdentifier?: string;
+    
+    PromotionTier?: number;
+    
+    DBInstanceArn?: string;
+    
+    EnabledCloudwatchLogsExports?: string[];
+}
+export declare namespace DBInstance {
+    
+    const filterSensitiveLog: (obj: DBInstance) => any;
+}
+export interface CreateDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace CreateDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceResult) => any;
+}
+
+export declare class DBInstanceAlreadyExistsFault extends __BaseException {
+    readonly name: "DBInstanceAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBSecurityGroupNotFoundFault extends __BaseException {
+    readonly name: "DBSecurityGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotFoundFault, __BaseException>);
+}
+
+export declare class InstanceQuotaExceededFault extends __BaseException {
+    readonly name: "InstanceQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InstanceQuotaExceededFault, __BaseException>);
+}
+
+export declare class InsufficientDBInstanceCapacityFault extends __BaseException {
+    readonly name: "InsufficientDBInstanceCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDBInstanceCapacityFault, __BaseException>);
+}
+
+export declare class StorageTypeNotSupportedFault extends __BaseException {
+    readonly name: "StorageTypeNotSupportedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<StorageTypeNotSupportedFault, __BaseException>);
+}
+
+export interface CreateDBSubnetGroupMessage {
+    
+    DBSubnetGroupName: string | undefined;
+    
+    DBSubnetGroupDescription: string | undefined;
+    
+    SubnetIds: string[] | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBSubnetGroupMessage) => any;
+}
+export interface CreateDBSubnetGroupResult {
+    
+    DBSubnetGroup?: DBSubnetGroup;
+}
+export declare namespace CreateDBSubnetGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateDBSubnetGroupResult) => any;
+}
+
+export declare class DBSubnetGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "DBSubnetGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBSubnetGroupQuotaExceededFault extends __BaseException {
+    readonly name: "DBSubnetGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBSubnetQuotaExceededFault extends __BaseException {
+    readonly name: "DBSubnetQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn: string | undefined;
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+    
+    SourceIds?: string[];
+    
+    Enabled?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionMessage) => any;
+}
+export interface CreateEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace CreateEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionResult) => any;
+}
+
+export declare class EventSubscriptionQuotaExceededFault extends __BaseException {
+    readonly name: "EventSubscriptionQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
+}
+
+export declare class SNSInvalidTopicFault extends __BaseException {
+    readonly name: "SNSInvalidTopicFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
+}
+
+export declare class SNSNoAuthorizationFault extends __BaseException {
+    readonly name: "SNSNoAuthorizationFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
+}
+
+export declare class SNSTopicArnNotFoundFault extends __BaseException {
+    readonly name: "SNSTopicArnNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionAlreadyExistFault extends __BaseException {
+    readonly name: "SubscriptionAlreadyExistFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
+}
+
+export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionCategoryNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
+}
+
+export interface CreateGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+    
+    SourceDBClusterIdentifier?: string;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DeletionProtection?: boolean;
+    
+    DatabaseName?: string;
+    
+    StorageEncrypted?: boolean;
+}
+export declare namespace CreateGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: CreateGlobalClusterMessage) => any;
+}
+
+export interface GlobalClusterMember {
+    
+    DBClusterArn?: string;
+    
+    Readers?: string[];
+    
+    IsWriter?: boolean;
+}
+export declare namespace GlobalClusterMember {
+    
+    const filterSensitiveLog: (obj: GlobalClusterMember) => any;
+}
+
+export interface GlobalCluster {
+    
+    GlobalClusterIdentifier?: string;
+    
+    GlobalClusterResourceId?: string;
+    
+    GlobalClusterArn?: string;
+    
+    Status?: string;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DatabaseName?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    DeletionProtection?: boolean;
+    
+    GlobalClusterMembers?: GlobalClusterMember[];
+}
+export declare namespace GlobalCluster {
+    
+    const filterSensitiveLog: (obj: GlobalCluster) => any;
+}
+export interface CreateGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace CreateGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateGlobalClusterResult) => any;
+}
+
+export declare class GlobalClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "GlobalClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterAlreadyExistsFault, __BaseException>);
+}
+
+export declare class GlobalClusterQuotaExceededFault extends __BaseException {
+    readonly name: "GlobalClusterQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterQuotaExceededFault, __BaseException>);
+}
+
+export interface DeleteDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    SkipFinalSnapshot?: boolean;
+    
+    FinalDBSnapshotIdentifier?: string;
+}
+export declare namespace DeleteDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterMessage) => any;
+}
+export interface DeleteDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace DeleteDBClusterResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterResult) => any;
+}
+
+export interface DeleteDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+}
+export declare namespace DeleteDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterParameterGroupMessage) => any;
+}
+
+export declare class InvalidDBParameterGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBParameterGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBParameterGroupStateFault, __BaseException>);
+}
+
+export interface DeleteDBClusterSnapshotMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+}
+export declare namespace DeleteDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterSnapshotMessage) => any;
+}
+export interface DeleteDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace DeleteDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterSnapshotResult) => any;
+}
+
+export declare class DBSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "DBSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSnapshotAlreadyExistsFault, __BaseException>);
+}
+
+export interface DeleteDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+}
+export declare namespace DeleteDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBInstanceMessage) => any;
+}
+export interface DeleteDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace DeleteDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBInstanceResult) => any;
+}
+
+export interface DeleteDBSubnetGroupMessage {
+    
+    DBSubnetGroupName: string | undefined;
+}
+export declare namespace DeleteDBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBSubnetGroupMessage) => any;
+}
+
+export declare class InvalidDBSubnetStateFault extends __BaseException {
+    readonly name: "InvalidDBSubnetStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSubnetStateFault, __BaseException>);
+}
+
+export interface DeleteEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+}
+export declare namespace DeleteEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionMessage) => any;
+}
+export interface DeleteEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace DeleteEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionResult) => any;
+}
+
+export declare class InvalidEventSubscriptionStateFault extends __BaseException {
+    readonly name: "InvalidEventSubscriptionStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidEventSubscriptionStateFault, __BaseException>);
+}
+
+export interface DeleteGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+}
+export declare namespace DeleteGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalClusterMessage) => any;
+}
+export interface DeleteGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace DeleteGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalClusterResult) => any;
+}
+
+export interface Certificate {
+    
+    CertificateIdentifier?: string;
+    
+    CertificateType?: string;
+    
+    Thumbprint?: string;
+    
+    ValidFrom?: Date;
+    
+    ValidTill?: Date;
+    
+    CertificateArn?: string;
+}
+export declare namespace Certificate {
+    
+    const filterSensitiveLog: (obj: Certificate) => any;
+}
+export interface CertificateMessage {
+    
+    Certificates?: Certificate[];
+    
+    Marker?: string;
+}
+export declare namespace CertificateMessage {
+    
+    const filterSensitiveLog: (obj: CertificateMessage) => any;
+}
+
+export declare class CertificateNotFoundFault extends __BaseException {
+    readonly name: "CertificateNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CertificateNotFoundFault, __BaseException>);
+}
+
+export interface Filter {
+    
+    Name: string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+export interface DescribeCertificatesMessage {
+    
+    CertificateIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeCertificatesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeCertificatesMessage) => any;
+}
+
+export interface DBClusterParameterGroupsMessage {
+    
+    Marker?: string;
+    
+    DBClusterParameterGroups?: DBClusterParameterGroup[];
+}
+export declare namespace DBClusterParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroupsMessage) => any;
+}
+
+export interface DescribeDBClusterParameterGroupsMessage {
+    
+    DBClusterParameterGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBClusterParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterParameterGroupsMessage) => any;
+}
+export declare type ApplyMethod = "immediate" | "pending-reboot";
+
+export interface Parameter {
+    
+    ParameterName?: string;
+    
+    ParameterValue?: string;
+    
+    Description?: string;
+    
+    Source?: string;
+    
+    ApplyType?: string;
+    
+    DataType?: string;
+    
+    AllowedValues?: string;
+    
+    IsModifiable?: boolean;
+    
+    MinimumEngineVersion?: string;
+    
+    ApplyMethod?: ApplyMethod | string;
+}
+export declare namespace Parameter {
+    
+    const filterSensitiveLog: (obj: Parameter) => any;
+}
+
+export interface DBClusterParameterGroupDetails {
+    
+    Parameters?: Parameter[];
+    
+    Marker?: string;
+}
+export declare namespace DBClusterParameterGroupDetails {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroupDetails) => any;
+}
+
+export interface DescribeDBClusterParametersMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    Source?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBClusterParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterParametersMessage) => any;
+}
+
+export interface DBClusterMessage {
+    
+    Marker?: string;
+    
+    DBClusters?: DBCluster[];
+}
+export declare namespace DBClusterMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterMessage) => any;
+}
+
+export interface DescribeDBClustersMessage {
+    
+    DBClusterIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBClustersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClustersMessage) => any;
+}
+
+export interface DescribeDBClusterSnapshotAttributesMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+}
+export declare namespace DescribeDBClusterSnapshotAttributesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterSnapshotAttributesMessage) => any;
+}
+
+export interface DBClusterSnapshotAttribute {
+    
+    AttributeName?: string;
+    
+    AttributeValues?: string[];
+}
+export declare namespace DBClusterSnapshotAttribute {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshotAttribute) => any;
+}
+
+export interface DBClusterSnapshotAttributesResult {
+    
+    DBClusterSnapshotIdentifier?: string;
+    
+    DBClusterSnapshotAttributes?: DBClusterSnapshotAttribute[];
+}
+export declare namespace DBClusterSnapshotAttributesResult {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshotAttributesResult) => any;
+}
+export interface DescribeDBClusterSnapshotAttributesResult {
+    
+    DBClusterSnapshotAttributesResult?: DBClusterSnapshotAttributesResult;
+}
+export declare namespace DescribeDBClusterSnapshotAttributesResult {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterSnapshotAttributesResult) => any;
+}
+
+export interface DBClusterSnapshotMessage {
+    
+    Marker?: string;
+    
+    DBClusterSnapshots?: DBClusterSnapshot[];
+}
+export declare namespace DBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshotMessage) => any;
+}
+
+export interface DescribeDBClusterSnapshotsMessage {
+    
+    DBClusterIdentifier?: string;
+    
+    DBClusterSnapshotIdentifier?: string;
+    
+    SnapshotType?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    IncludeShared?: boolean;
+    
+    IncludePublic?: boolean;
+}
+export declare namespace DescribeDBClusterSnapshotsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterSnapshotsMessage) => any;
+}
+
+export interface UpgradeTarget {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    Description?: string;
+    
+    AutoUpgrade?: boolean;
+    
+    IsMajorVersionUpgrade?: boolean;
+}
+export declare namespace UpgradeTarget {
+    
+    const filterSensitiveLog: (obj: UpgradeTarget) => any;
+}
+
+export interface DBEngineVersion {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    DBEngineDescription?: string;
+    
+    DBEngineVersionDescription?: string;
+    
+    ValidUpgradeTarget?: UpgradeTarget[];
+    
+    ExportableLogTypes?: string[];
+    
+    SupportsLogExportsToCloudwatchLogs?: boolean;
+}
+export declare namespace DBEngineVersion {
+    
+    const filterSensitiveLog: (obj: DBEngineVersion) => any;
+}
+
+export interface DBEngineVersionMessage {
+    
+    Marker?: string;
+    
+    DBEngineVersions?: DBEngineVersion[];
+}
+export declare namespace DBEngineVersionMessage {
+    
+    const filterSensitiveLog: (obj: DBEngineVersionMessage) => any;
+}
+
+export interface DescribeDBEngineVersionsMessage {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    DefaultOnly?: boolean;
+    
+    ListSupportedCharacterSets?: boolean;
+    
+    ListSupportedTimezones?: boolean;
+}
+export declare namespace DescribeDBEngineVersionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBEngineVersionsMessage) => any;
+}
+
+export interface DBInstanceMessage {
+    
+    Marker?: string;
+    
+    DBInstances?: DBInstance[];
+}
+export declare namespace DBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: DBInstanceMessage) => any;
+}
+
+export interface DescribeDBInstancesMessage {
+    
+    DBInstanceIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBInstancesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBInstancesMessage) => any;
+}
+
+export interface DBSubnetGroupMessage {
+    
+    Marker?: string;
+    
+    DBSubnetGroups?: DBSubnetGroup[];
+}
+export declare namespace DBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupMessage) => any;
+}
+
+export interface DescribeDBSubnetGroupsMessage {
+    
+    DBSubnetGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBSubnetGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBSubnetGroupsMessage) => any;
+}
+
+export interface DescribeEngineDefaultClusterParametersMessage {
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEngineDefaultClusterParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultClusterParametersMessage) => any;
+}
+
+export interface EngineDefaults {
+    
+    DBParameterGroupFamily?: string;
+    
+    Marker?: string;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace EngineDefaults {
+    
+    const filterSensitiveLog: (obj: EngineDefaults) => any;
+}
+export interface DescribeEngineDefaultClusterParametersResult {
+    
+    EngineDefaults?: EngineDefaults;
+}
+export declare namespace DescribeEngineDefaultClusterParametersResult {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultClusterParametersResult) => any;
+}
+
+export interface DescribeEventCategoriesMessage {
+    
+    SourceType?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace DescribeEventCategoriesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventCategoriesMessage) => any;
+}
+
+export interface EventCategoriesMap {
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+}
+export declare namespace EventCategoriesMap {
+    
+    const filterSensitiveLog: (obj: EventCategoriesMap) => any;
+}
+
+export interface EventCategoriesMessage {
+    
+    EventCategoriesMapList?: EventCategoriesMap[];
+}
+export declare namespace EventCategoriesMessage {
+    
+    const filterSensitiveLog: (obj: EventCategoriesMessage) => any;
+}
+export declare type SourceType = "db-cluster" | "db-cluster-snapshot" | "db-instance" | "db-parameter-group" | "db-security-group" | "db-snapshot";
+
+export interface DescribeEventsMessage {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Duration?: number;
+    
+    EventCategories?: string[];
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventsMessage) => any;
+}
+
+export interface Event {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    Message?: string;
+    
+    EventCategories?: string[];
+    
+    Date?: Date;
+    
+    SourceArn?: string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface EventsMessage {
+    
+    Marker?: string;
+    
+    Events?: Event[];
+}
+export declare namespace EventsMessage {
+    
+    const filterSensitiveLog: (obj: EventsMessage) => any;
+}
+
+export interface DescribeEventSubscriptionsMessage {
+    
+    SubscriptionName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventSubscriptionsMessage) => any;
+}
+
+export interface EventSubscriptionsMessage {
+    
+    Marker?: string;
+    
+    EventSubscriptionsList?: EventSubscription[];
+}
+export declare namespace EventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EventSubscriptionsMessage) => any;
+}
+export interface DescribeGlobalClustersMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeGlobalClustersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalClustersMessage) => any;
+}
+export interface GlobalClustersMessage {
+    
+    Marker?: string;
+    
+    GlobalClusters?: GlobalCluster[];
+}
+export declare namespace GlobalClustersMessage {
+    
+    const filterSensitiveLog: (obj: GlobalClustersMessage) => any;
+}
+
+export interface DescribeOrderableDBInstanceOptionsMessage {
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    DBInstanceClass?: string;
+    
+    LicenseModel?: string;
+    
+    Vpc?: boolean;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeOrderableDBInstanceOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeOrderableDBInstanceOptionsMessage) => any;
+}
+
+export interface OrderableDBInstanceOption {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DBInstanceClass?: string;
+    
+    LicenseModel?: string;
+    
+    AvailabilityZones?: AvailabilityZone[];
+    
+    Vpc?: boolean;
+}
+export declare namespace OrderableDBInstanceOption {
+    
+    const filterSensitiveLog: (obj: OrderableDBInstanceOption) => any;
+}
+
+export interface OrderableDBInstanceOptionsMessage {
+    
+    OrderableDBInstanceOptions?: OrderableDBInstanceOption[];
+    
+    Marker?: string;
+}
+export declare namespace OrderableDBInstanceOptionsMessage {
+    
+    const filterSensitiveLog: (obj: OrderableDBInstanceOptionsMessage) => any;
+}
+
+export interface DescribePendingMaintenanceActionsMessage {
+    
+    ResourceIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribePendingMaintenanceActionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribePendingMaintenanceActionsMessage) => any;
+}
+
+export interface PendingMaintenanceActionsMessage {
+    
+    PendingMaintenanceActions?: ResourcePendingMaintenanceActions[];
+    
+    Marker?: string;
+}
+export declare namespace PendingMaintenanceActionsMessage {
+    
+    const filterSensitiveLog: (obj: PendingMaintenanceActionsMessage) => any;
+}
+
+export interface FailoverDBClusterMessage {
+    
+    DBClusterIdentifier?: string;
+    
+    TargetDBInstanceIdentifier?: string;
+}
+export declare namespace FailoverDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: FailoverDBClusterMessage) => any;
+}
+export interface FailoverDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace FailoverDBClusterResult {
+    
+    const filterSensitiveLog: (obj: FailoverDBClusterResult) => any;
+}
+
+export interface ListTagsForResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListTagsForResourceMessage {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceMessage) => any;
+}
+
+export interface TagListMessage {
+    
+    TagList?: Tag[];
+}
+export declare namespace TagListMessage {
+    
+    const filterSensitiveLog: (obj: TagListMessage) => any;
+}
+
+export declare class InvalidDBSecurityGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBSecurityGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSecurityGroupStateFault, __BaseException>);
+}
+
+export interface CloudwatchLogsExportConfiguration {
+    
+    EnableLogTypes?: string[];
+    
+    DisableLogTypes?: string[];
+}
+export declare namespace CloudwatchLogsExportConfiguration {
+    
+    const filterSensitiveLog: (obj: CloudwatchLogsExportConfiguration) => any;
+}
+
+export interface ModifyDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    NewDBClusterIdentifier?: string;
+    
+    ApplyImmediately?: boolean;
+    
+    BackupRetentionPeriod?: number;
+    
+    DBClusterParameterGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Port?: number;
+    
+    MasterUserPassword?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    CloudwatchLogsExportConfiguration?: CloudwatchLogsExportConfiguration;
+    
+    EngineVersion?: string;
+    
+    DeletionProtection?: boolean;
+}
+export declare namespace ModifyDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterMessage) => any;
+}
+export interface ModifyDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace ModifyDBClusterResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterResult) => any;
+}
+
+export interface DBClusterParameterGroupNameMessage {
+    
+    DBClusterParameterGroupName?: string;
+}
+export declare namespace DBClusterParameterGroupNameMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroupNameMessage) => any;
+}
+
+export interface ModifyDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    Parameters: Parameter[] | undefined;
+}
+export declare namespace ModifyDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterParameterGroupMessage) => any;
+}
+
+export interface ModifyDBClusterSnapshotAttributeMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+    
+    AttributeName: string | undefined;
+    
+    ValuesToAdd?: string[];
+    
+    ValuesToRemove?: string[];
+}
+export declare namespace ModifyDBClusterSnapshotAttributeMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterSnapshotAttributeMessage) => any;
+}
+export interface ModifyDBClusterSnapshotAttributeResult {
+    
+    DBClusterSnapshotAttributesResult?: DBClusterSnapshotAttributesResult;
+}
+export declare namespace ModifyDBClusterSnapshotAttributeResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterSnapshotAttributeResult) => any;
+}
+
+export declare class SharedSnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SharedSnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SharedSnapshotQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBUpgradeDependencyFailureFault extends __BaseException {
+    readonly name: "DBUpgradeDependencyFailureFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBUpgradeDependencyFailureFault, __BaseException>);
+}
+
+export interface ModifyDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    DBInstanceClass?: string;
+    
+    ApplyImmediately?: boolean;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    NewDBInstanceIdentifier?: string;
+    
+    CACertificateIdentifier?: string;
+    
+    PromotionTier?: number;
+}
+export declare namespace ModifyDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBInstanceMessage) => any;
+}
+export interface ModifyDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace ModifyDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBInstanceResult) => any;
+}
+
+export interface ModifyDBSubnetGroupMessage {
+    
+    DBSubnetGroupName: string | undefined;
+    
+    DBSubnetGroupDescription?: string;
+    
+    SubnetIds: string[] | undefined;
+}
+export declare namespace ModifyDBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBSubnetGroupMessage) => any;
+}
+export interface ModifyDBSubnetGroupResult {
+    
+    DBSubnetGroup?: DBSubnetGroup;
+}
+export declare namespace ModifyDBSubnetGroupResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBSubnetGroupResult) => any;
+}
+
+export declare class SubnetAlreadyInUse extends __BaseException {
+    readonly name: "SubnetAlreadyInUse";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubnetAlreadyInUse, __BaseException>);
+}
+
+export interface ModifyEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn?: string;
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+    
+    Enabled?: boolean;
+}
+export declare namespace ModifyEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionMessage) => any;
+}
+export interface ModifyEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace ModifyEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionResult) => any;
+}
+
+export interface ModifyGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+    
+    NewGlobalClusterIdentifier?: string;
+    
+    DeletionProtection?: boolean;
+}
+export declare namespace ModifyGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: ModifyGlobalClusterMessage) => any;
+}
+export interface ModifyGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace ModifyGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: ModifyGlobalClusterResult) => any;
+}
+
+export interface RebootDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    ForceFailover?: boolean;
+}
+export declare namespace RebootDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceMessage) => any;
+}
+export interface RebootDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RebootDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceResult) => any;
+}
+
+export interface RemoveFromGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+    
+    DbClusterIdentifier: string | undefined;
+}
+export declare namespace RemoveFromGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: RemoveFromGlobalClusterMessage) => any;
+}
+export interface RemoveFromGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace RemoveFromGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: RemoveFromGlobalClusterResult) => any;
+}
+
+export interface RemoveSourceIdentifierFromSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SourceIdentifier: string | undefined;
+}
+export declare namespace RemoveSourceIdentifierFromSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: RemoveSourceIdentifierFromSubscriptionMessage) => any;
+}
+export interface RemoveSourceIdentifierFromSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace RemoveSourceIdentifierFromSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: RemoveSourceIdentifierFromSubscriptionResult) => any;
+}
+
+export interface RemoveTagsFromResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace RemoveTagsFromResourceMessage {
+    
+    const filterSensitiveLog: (obj: RemoveTagsFromResourceMessage) => any;
+}
+
+export interface ResetDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    ResetAllParameters?: boolean;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace ResetDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ResetDBClusterParameterGroupMessage) => any;
+}
+
+export declare class InsufficientDBClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientDBClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDBClusterCapacityFault, __BaseException>);
+}
+
+export declare class InvalidDBSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidDBSnapshotStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSnapshotStateFault, __BaseException>);
+}
+
+export declare class InvalidRestoreFault extends __BaseException {
+    readonly name: "InvalidRestoreFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRestoreFault, __BaseException>);
+}
+
+export interface RestoreDBClusterFromSnapshotMessage {
+    
+    AvailabilityZones?: string[];
+    
+    DBClusterIdentifier: string | undefined;
+    
+    SnapshotIdentifier: string | undefined;
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    Port?: number;
+    
+    DBSubnetGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    DeletionProtection?: boolean;
+}
+export declare namespace RestoreDBClusterFromSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromSnapshotMessage) => any;
+}
+export interface RestoreDBClusterFromSnapshotResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RestoreDBClusterFromSnapshotResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromSnapshotResult) => any;
+}
+
+export interface RestoreDBClusterToPointInTimeMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    SourceDBClusterIdentifier: string | undefined;
+    
+    RestoreToTime?: Date;
+    
+    UseLatestRestorableTime?: boolean;
+    
+    Port?: number;
+    
+    DBSubnetGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    DeletionProtection?: boolean;
+}
+export declare namespace RestoreDBClusterToPointInTimeMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterToPointInTimeMessage) => any;
+}
+export interface RestoreDBClusterToPointInTimeResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RestoreDBClusterToPointInTimeResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterToPointInTimeResult) => any;
+}
+export interface StartDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace StartDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: StartDBClusterMessage) => any;
+}
+export interface StartDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace StartDBClusterResult {
+    
+    const filterSensitiveLog: (obj: StartDBClusterResult) => any;
+}
+export interface StopDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace StopDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: StopDBClusterMessage) => any;
+}
+export interface StopDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace StopDBClusterResult {
+    
+    const filterSensitiveLog: (obj: StopDBClusterResult) => any;
+}