@aws-sdk/client-rds 3.34.0 → 3.37.0

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

@@ -0,0 +1,4210 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccountQuota {
+    
+    AccountQuotaName?: string;
+    
+    Used?: number;
+    
+    Max?: number;
+}
+export declare namespace AccountQuota {
+    
+    const filterSensitiveLog: (obj: AccountQuota) => any;
+}
+
+export interface AccountAttributesMessage {
+    
+    AccountQuotas?: AccountQuota[];
+}
+export declare namespace AccountAttributesMessage {
+    
+    const filterSensitiveLog: (obj: AccountAttributesMessage) => any;
+}
+export declare type ActivityStreamMode = "async" | "sync";
+export declare type ActivityStreamStatus = "started" | "starting" | "stopped" | "stopping";
+export interface AddRoleToDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName?: string;
+}
+export declare namespace AddRoleToDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: AddRoleToDBClusterMessage) => any;
+}
+
+export interface DBClusterNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterNotFoundFault) => any;
+}
+
+export interface DBClusterRoleAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterRoleAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterRoleAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBClusterRoleAlreadyExistsFault) => any;
+}
+
+export interface DBClusterRoleQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterRoleQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterRoleQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBClusterRoleQuotaExceededFault) => any;
+}
+
+export interface InvalidDBClusterStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBClusterStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBClusterStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBClusterStateFault) => any;
+}
+export interface AddRoleToDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName: string | undefined;
+}
+export declare namespace AddRoleToDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: AddRoleToDBInstanceMessage) => any;
+}
+
+export interface DBInstanceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceNotFoundFault) => any;
+}
+
+export interface DBInstanceRoleAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceRoleAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceRoleAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceRoleAlreadyExistsFault) => any;
+}
+
+export interface DBInstanceRoleQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceRoleQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceRoleQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceRoleQuotaExceededFault) => any;
+}
+
+export interface InvalidDBInstanceStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBInstanceStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBInstanceStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBInstanceStateFault) => any;
+}
+
+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 interface SourceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SourceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SourceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SourceNotFoundFault) => any;
+}
+
+export interface SubscriptionNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionNotFoundFault) => any;
+}
+
+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 interface DBProxyNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBProxyNotFoundFault) => any;
+}
+
+export interface DBProxyTargetGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyTargetGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyTargetGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBProxyTargetGroupNotFoundFault) => any;
+}
+
+export interface DBSnapshotNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBSnapshotNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSnapshotNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBSnapshotNotFoundFault) => any;
+}
+
+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 interface ResourceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundFault) => any;
+}
+
+export interface AuthorizationAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationAlreadyExistsFault) => any;
+}
+
+export interface AuthorizationQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationQuotaExceededFault) => any;
+}
+
+export interface AuthorizeDBSecurityGroupIngressMessage {
+    
+    DBSecurityGroupName: string | undefined;
+    
+    CIDRIP?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupId?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+}
+export declare namespace AuthorizeDBSecurityGroupIngressMessage {
+    
+    const filterSensitiveLog: (obj: AuthorizeDBSecurityGroupIngressMessage) => any;
+}
+
+export interface EC2SecurityGroup {
+    
+    Status?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupId?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+}
+export declare namespace EC2SecurityGroup {
+    
+    const filterSensitiveLog: (obj: EC2SecurityGroup) => any;
+}
+
+export interface IPRange {
+    
+    Status?: string;
+    
+    CIDRIP?: string;
+}
+export declare namespace IPRange {
+    
+    const filterSensitiveLog: (obj: IPRange) => any;
+}
+
+export interface DBSecurityGroup {
+    
+    OwnerId?: string;
+    
+    DBSecurityGroupName?: string;
+    
+    DBSecurityGroupDescription?: string;
+    
+    VpcId?: string;
+    
+    EC2SecurityGroups?: EC2SecurityGroup[];
+    
+    IPRanges?: IPRange[];
+    
+    DBSecurityGroupArn?: string;
+}
+export declare namespace DBSecurityGroup {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroup) => any;
+}
+export interface AuthorizeDBSecurityGroupIngressResult {
+    
+    DBSecurityGroup?: DBSecurityGroup;
+}
+export declare namespace AuthorizeDBSecurityGroupIngressResult {
+    
+    const filterSensitiveLog: (obj: AuthorizeDBSecurityGroupIngressResult) => any;
+}
+
+export interface DBSecurityGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBSecurityGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSecurityGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupNotFoundFault) => any;
+}
+
+export interface InvalidDBSecurityGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBSecurityGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBSecurityGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBSecurityGroupStateFault) => any;
+}
+
+export interface BacktrackDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    BacktrackTo: Date | undefined;
+    
+    Force?: boolean;
+    
+    UseEarliestTimeOnPointInTimeUnavailable?: boolean;
+}
+export declare namespace BacktrackDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: BacktrackDBClusterMessage) => any;
+}
+
+export interface DBClusterBacktrack {
+    
+    DBClusterIdentifier?: string;
+    
+    BacktrackIdentifier?: string;
+    
+    BacktrackTo?: Date;
+    
+    BacktrackedFrom?: Date;
+    
+    BacktrackRequestCreationTime?: Date;
+    
+    Status?: string;
+}
+export declare namespace DBClusterBacktrack {
+    
+    const filterSensitiveLog: (obj: DBClusterBacktrack) => any;
+}
+export interface CancelExportTaskMessage {
+    
+    ExportTaskIdentifier: string | undefined;
+}
+export declare namespace CancelExportTaskMessage {
+    
+    const filterSensitiveLog: (obj: CancelExportTaskMessage) => any;
+}
+
+export interface ExportTask {
+    
+    ExportTaskIdentifier?: string;
+    
+    SourceArn?: string;
+    
+    ExportOnly?: string[];
+    
+    SnapshotTime?: Date;
+    
+    TaskStartTime?: Date;
+    
+    TaskEndTime?: Date;
+    
+    S3Bucket?: string;
+    
+    S3Prefix?: string;
+    
+    IamRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    Status?: string;
+    
+    PercentProgress?: number;
+    
+    TotalExtractedDataInGB?: number;
+    
+    FailureCause?: string;
+    
+    WarningMessage?: string;
+}
+export declare namespace ExportTask {
+    
+    const filterSensitiveLog: (obj: ExportTask) => any;
+}
+
+export interface ExportTaskNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ExportTaskNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ExportTaskNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ExportTaskNotFoundFault) => any;
+}
+
+export interface InvalidExportTaskStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidExportTaskStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidExportTaskStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidExportTaskStateFault) => any;
+}
+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 interface DBParameterGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBParameterGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBParameterGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupAlreadyExistsFault) => any;
+}
+
+export interface DBParameterGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBParameterGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBParameterGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupNotFoundFault) => any;
+}
+
+export interface DBParameterGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBParameterGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBParameterGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupQuotaExceededFault) => any;
+}
+
+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;
+    
+    EngineMode?: string;
+    
+    AllocatedStorage?: number;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    VpcId?: string;
+    
+    ClusterCreateTime?: Date;
+    
+    MasterUsername?: string;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    SnapshotType?: string;
+    
+    PercentProgress?: number;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DBClusterSnapshotArn?: string;
+    
+    SourceDBClusterSnapshotArn?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    TagList?: Tag[];
+}
+export declare namespace DBClusterSnapshot {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshot) => any;
+}
+export interface CopyDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace CopyDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterSnapshotResult) => any;
+}
+
+export interface DBClusterSnapshotAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterSnapshotAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterSnapshotAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshotAlreadyExistsFault) => any;
+}
+
+export interface DBClusterSnapshotNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterSnapshotNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterSnapshotNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterSnapshotNotFoundFault) => any;
+}
+
+export interface InvalidDBClusterSnapshotStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBClusterSnapshotStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBClusterSnapshotStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBClusterSnapshotStateFault) => any;
+}
+
+export interface KMSKeyNotAccessibleFault extends __SmithyException, $MetadataBearer {
+    name: "KMSKeyNotAccessibleFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace KMSKeyNotAccessibleFault {
+    
+    const filterSensitiveLog: (obj: KMSKeyNotAccessibleFault) => any;
+}
+
+export interface SnapshotQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "SnapshotQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SnapshotQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: SnapshotQuotaExceededFault) => any;
+}
+
+export interface CopyDBParameterGroupMessage {
+    
+    SourceDBParameterGroupIdentifier: string | undefined;
+    
+    TargetDBParameterGroupIdentifier: string | undefined;
+    
+    TargetDBParameterGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyDBParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBParameterGroupMessage) => any;
+}
+
+export interface DBParameterGroup {
+    
+    DBParameterGroupName?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    Description?: string;
+    
+    DBParameterGroupArn?: string;
+}
+export declare namespace DBParameterGroup {
+    
+    const filterSensitiveLog: (obj: DBParameterGroup) => any;
+}
+export interface CopyDBParameterGroupResult {
+    
+    DBParameterGroup?: DBParameterGroup;
+}
+export declare namespace CopyDBParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CopyDBParameterGroupResult) => any;
+}
+
+export interface CopyDBSnapshotMessage {
+    
+    SourceDBSnapshotIdentifier: string | undefined;
+    
+    TargetDBSnapshotIdentifier: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    Tags?: Tag[];
+    
+    CopyTags?: boolean;
+    
+    PreSignedUrl?: string;
+    
+    OptionGroupName?: string;
+    
+    TargetCustomAvailabilityZone?: string;
+}
+export declare namespace CopyDBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBSnapshotMessage) => any;
+}
+
+export interface ProcessorFeature {
+    
+    Name?: string;
+    
+    Value?: string;
+}
+export declare namespace ProcessorFeature {
+    
+    const filterSensitiveLog: (obj: ProcessorFeature) => any;
+}
+
+export interface DBSnapshot {
+    
+    DBSnapshotIdentifier?: string;
+    
+    DBInstanceIdentifier?: string;
+    
+    SnapshotCreateTime?: Date;
+    
+    Engine?: string;
+    
+    AllocatedStorage?: number;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    VpcId?: string;
+    
+    InstanceCreateTime?: Date;
+    
+    MasterUsername?: string;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    SnapshotType?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    PercentProgress?: number;
+    
+    SourceRegion?: string;
+    
+    SourceDBSnapshotIdentifier?: string;
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DBSnapshotArn?: string;
+    
+    Timezone?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    DbiResourceId?: string;
+    
+    TagList?: Tag[];
+    
+    OriginalSnapshotCreateTime?: Date;
+}
+export declare namespace DBSnapshot {
+    
+    const filterSensitiveLog: (obj: DBSnapshot) => any;
+}
+export interface CopyDBSnapshotResult {
+    
+    DBSnapshot?: DBSnapshot;
+}
+export declare namespace CopyDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CopyDBSnapshotResult) => any;
+}
+
+export interface CustomAvailabilityZoneNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "CustomAvailabilityZoneNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CustomAvailabilityZoneNotFoundFault {
+    
+    const filterSensitiveLog: (obj: CustomAvailabilityZoneNotFoundFault) => any;
+}
+
+export interface DBSnapshotAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBSnapshotAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSnapshotAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBSnapshotAlreadyExistsFault) => any;
+}
+
+export interface InvalidDBSnapshotStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBSnapshotStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBSnapshotStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBSnapshotStateFault) => any;
+}
+
+export interface CopyOptionGroupMessage {
+    
+    SourceOptionGroupIdentifier: string | undefined;
+    
+    TargetOptionGroupIdentifier: string | undefined;
+    
+    TargetOptionGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyOptionGroupMessage {
+    
+    const filterSensitiveLog: (obj: CopyOptionGroupMessage) => any;
+}
+
+export interface DBSecurityGroupMembership {
+    
+    DBSecurityGroupName?: string;
+    
+    Status?: string;
+}
+export declare namespace DBSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupMembership) => any;
+}
+
+export interface OptionSetting {
+    
+    Name?: string;
+    
+    Value?: string;
+    
+    DefaultValue?: string;
+    
+    Description?: string;
+    
+    ApplyType?: string;
+    
+    DataType?: string;
+    
+    AllowedValues?: string;
+    
+    IsModifiable?: boolean;
+    
+    IsCollection?: boolean;
+}
+export declare namespace OptionSetting {
+    
+    const filterSensitiveLog: (obj: OptionSetting) => any;
+}
+
+export interface VpcSecurityGroupMembership {
+    
+    VpcSecurityGroupId?: string;
+    
+    Status?: string;
+}
+export declare namespace VpcSecurityGroupMembership {
+    
+    const filterSensitiveLog: (obj: VpcSecurityGroupMembership) => any;
+}
+
+export interface Option {
+    
+    OptionName?: string;
+    
+    OptionDescription?: string;
+    
+    Persistent?: boolean;
+    
+    Permanent?: boolean;
+    
+    Port?: number;
+    
+    OptionVersion?: string;
+    
+    OptionSettings?: OptionSetting[];
+    
+    DBSecurityGroupMemberships?: DBSecurityGroupMembership[];
+    
+    VpcSecurityGroupMemberships?: VpcSecurityGroupMembership[];
+}
+export declare namespace Option {
+    
+    const filterSensitiveLog: (obj: Option) => any;
+}
+
+export interface OptionGroup {
+    
+    OptionGroupName?: string;
+    
+    OptionGroupDescription?: string;
+    
+    EngineName?: string;
+    
+    MajorEngineVersion?: string;
+    
+    Options?: Option[];
+    
+    AllowsVpcAndNonVpcInstanceMemberships?: boolean;
+    
+    VpcId?: string;
+    
+    OptionGroupArn?: string;
+}
+export declare namespace OptionGroup {
+    
+    const filterSensitiveLog: (obj: OptionGroup) => any;
+}
+export interface CopyOptionGroupResult {
+    
+    OptionGroup?: OptionGroup;
+}
+export declare namespace CopyOptionGroupResult {
+    
+    const filterSensitiveLog: (obj: CopyOptionGroupResult) => any;
+}
+
+export interface OptionGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "OptionGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OptionGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: OptionGroupAlreadyExistsFault) => any;
+}
+
+export interface OptionGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "OptionGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OptionGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: OptionGroupNotFoundFault) => any;
+}
+
+export interface OptionGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "OptionGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OptionGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: OptionGroupQuotaExceededFault) => any;
+}
+
+export interface CreateCustomAvailabilityZoneMessage {
+    
+    CustomAvailabilityZoneName: string | undefined;
+    
+    ExistingVpnId?: string;
+    
+    NewVpnTunnelName?: string;
+    
+    VpnTunnelOriginatorIP?: string;
+}
+export declare namespace CreateCustomAvailabilityZoneMessage {
+    
+    const filterSensitiveLog: (obj: CreateCustomAvailabilityZoneMessage) => any;
+}
+
+export interface VpnDetails {
+    
+    VpnId?: string;
+    
+    VpnTunnelOriginatorIP?: string;
+    
+    VpnGatewayIp?: string;
+    
+    VpnPSK?: string;
+    
+    VpnName?: string;
+    
+    VpnState?: string;
+}
+export declare namespace VpnDetails {
+    
+    const filterSensitiveLog: (obj: VpnDetails) => any;
+}
+
+export interface CustomAvailabilityZone {
+    
+    CustomAvailabilityZoneId?: string;
+    
+    CustomAvailabilityZoneName?: string;
+    
+    CustomAvailabilityZoneStatus?: string;
+    
+    VpnDetails?: VpnDetails;
+}
+export declare namespace CustomAvailabilityZone {
+    
+    const filterSensitiveLog: (obj: CustomAvailabilityZone) => any;
+}
+export interface CreateCustomAvailabilityZoneResult {
+    
+    CustomAvailabilityZone?: CustomAvailabilityZone;
+}
+export declare namespace CreateCustomAvailabilityZoneResult {
+    
+    const filterSensitiveLog: (obj: CreateCustomAvailabilityZoneResult) => any;
+}
+
+export interface CustomAvailabilityZoneAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "CustomAvailabilityZoneAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CustomAvailabilityZoneAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: CustomAvailabilityZoneAlreadyExistsFault) => any;
+}
+
+export interface CustomAvailabilityZoneQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "CustomAvailabilityZoneQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CustomAvailabilityZoneQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: CustomAvailabilityZoneQuotaExceededFault) => any;
+}
+
+export interface ScalingConfiguration {
+    
+    MinCapacity?: number;
+    
+    MaxCapacity?: number;
+    
+    AutoPause?: boolean;
+    
+    SecondsUntilAutoPause?: number;
+    
+    TimeoutAction?: string;
+    
+    SecondsBeforeTimeout?: number;
+}
+export declare namespace ScalingConfiguration {
+    
+    const filterSensitiveLog: (obj: ScalingConfiguration) => any;
+}
+
+export interface CreateDBClusterMessage {
+    
+    AvailabilityZones?: string[];
+    
+    BackupRetentionPeriod?: number;
+    
+    CharacterSetName?: string;
+    
+    DatabaseName?: string;
+    
+    DBClusterIdentifier: string | undefined;
+    
+    DBClusterParameterGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    DBSubnetGroupName?: string;
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    Port?: number;
+    
+    MasterUsername?: string;
+    
+    MasterUserPassword?: string;
+    
+    OptionGroupName?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    ReplicationSourceIdentifier?: string;
+    
+    Tags?: Tag[];
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    BacktrackWindow?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    EngineMode?: string;
+    
+    ScalingConfiguration?: ScalingConfiguration;
+    
+    DeletionProtection?: boolean;
+    
+    GlobalClusterIdentifier?: string;
+    
+    EnableHttpEndpoint?: boolean;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    EnableGlobalWriteForwarding?: boolean;
+}
+export declare namespace CreateDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterMessage) => any;
+}
+
+export interface DBClusterRole {
+    
+    RoleArn?: string;
+    
+    Status?: string;
+    
+    FeatureName?: 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 DBClusterOptionGroupStatus {
+    
+    DBClusterOptionGroupName?: string;
+    
+    Status?: string;
+}
+export declare namespace DBClusterOptionGroupStatus {
+    
+    const filterSensitiveLog: (obj: DBClusterOptionGroupStatus) => any;
+}
+
+export interface DomainMembership {
+    
+    Domain?: string;
+    
+    Status?: string;
+    
+    FQDN?: string;
+    
+    IAMRoleName?: string;
+}
+export declare namespace DomainMembership {
+    
+    const filterSensitiveLog: (obj: DomainMembership) => any;
+}
+export declare enum WriteForwardingStatus {
+    DISABLED = "disabled",
+    DISABLING = "disabling",
+    ENABLED = "enabled",
+    ENABLING = "enabling",
+    UNKNOWN = "unknown"
+}
+
+export interface PendingCloudwatchLogsExports {
+    
+    LogTypesToEnable?: string[];
+    
+    LogTypesToDisable?: string[];
+}
+export declare namespace PendingCloudwatchLogsExports {
+    
+    const filterSensitiveLog: (obj: PendingCloudwatchLogsExports) => any;
+}
+
+export interface ClusterPendingModifiedValues {
+    
+    PendingCloudwatchLogsExports?: PendingCloudwatchLogsExports;
+    
+    DBClusterIdentifier?: string;
+    
+    MasterUserPassword?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    EngineVersion?: string;
+}
+export declare namespace ClusterPendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: ClusterPendingModifiedValues) => any;
+}
+
+export interface ScalingConfigurationInfo {
+    
+    MinCapacity?: number;
+    
+    MaxCapacity?: number;
+    
+    AutoPause?: boolean;
+    
+    SecondsUntilAutoPause?: number;
+    
+    TimeoutAction?: string;
+    
+    SecondsBeforeTimeout?: number;
+}
+export declare namespace ScalingConfigurationInfo {
+    
+    const filterSensitiveLog: (obj: ScalingConfigurationInfo) => any;
+}
+
+export interface DBCluster {
+    
+    AllocatedStorage?: number;
+    
+    AvailabilityZones?: string[];
+    
+    BackupRetentionPeriod?: number;
+    
+    CharacterSetName?: string;
+    
+    DatabaseName?: string;
+    
+    DBClusterIdentifier?: string;
+    
+    DBClusterParameterGroup?: string;
+    
+    DBSubnetGroup?: string;
+    
+    Status?: string;
+    
+    AutomaticRestartTime?: Date;
+    
+    PercentProgress?: string;
+    
+    EarliestRestorableTime?: Date;
+    
+    Endpoint?: string;
+    
+    ReaderEndpoint?: string;
+    
+    CustomEndpoints?: string[];
+    
+    MultiAZ?: boolean;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    LatestRestorableTime?: Date;
+    
+    Port?: number;
+    
+    MasterUsername?: string;
+    
+    DBClusterOptionGroupMemberships?: DBClusterOptionGroupStatus[];
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    ReplicationSourceIdentifier?: string;
+    
+    ReadReplicaIdentifiers?: string[];
+    
+    DBClusterMembers?: DBClusterMember[];
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    HostedZoneId?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DbClusterResourceId?: string;
+    
+    DBClusterArn?: string;
+    
+    AssociatedRoles?: DBClusterRole[];
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    CloneGroupId?: string;
+    
+    ClusterCreateTime?: Date;
+    
+    EarliestBacktrackTime?: Date;
+    
+    BacktrackWindow?: number;
+    
+    BacktrackConsumedChangeRecords?: number;
+    
+    EnabledCloudwatchLogsExports?: string[];
+    
+    Capacity?: number;
+    
+    EngineMode?: string;
+    
+    ScalingConfigurationInfo?: ScalingConfigurationInfo;
+    
+    DeletionProtection?: boolean;
+    
+    HttpEndpointEnabled?: boolean;
+    
+    ActivityStreamMode?: ActivityStreamMode | string;
+    
+    ActivityStreamStatus?: ActivityStreamStatus | string;
+    
+    ActivityStreamKmsKeyId?: string;
+    
+    ActivityStreamKinesisStreamName?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    CrossAccountClone?: boolean;
+    
+    DomainMemberships?: DomainMembership[];
+    
+    TagList?: Tag[];
+    
+    GlobalWriteForwardingStatus?: WriteForwardingStatus | string;
+    
+    GlobalWriteForwardingRequested?: boolean;
+    
+    PendingModifiedValues?: ClusterPendingModifiedValues;
+}
+export declare namespace DBCluster {
+    
+    const filterSensitiveLog: (obj: DBCluster) => any;
+}
+export interface CreateDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace CreateDBClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterResult) => any;
+}
+
+export interface DBClusterAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBClusterAlreadyExistsFault) => any;
+}
+
+export interface DBClusterParameterGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterParameterGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterParameterGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroupNotFoundFault) => any;
+}
+
+export interface DBClusterQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBClusterQuotaExceededFault) => any;
+}
+
+export interface DBSubnetGroupDoesNotCoverEnoughAZs extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetGroupDoesNotCoverEnoughAZs";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetGroupDoesNotCoverEnoughAZs {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupDoesNotCoverEnoughAZs) => any;
+}
+
+export interface DBSubnetGroupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetGroupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetGroupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupNotFoundFault) => any;
+}
+
+export interface DomainNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DomainNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DomainNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DomainNotFoundFault) => any;
+}
+
+export interface GlobalClusterNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "GlobalClusterNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace GlobalClusterNotFoundFault {
+    
+    const filterSensitiveLog: (obj: GlobalClusterNotFoundFault) => any;
+}
+
+export interface InsufficientStorageClusterCapacityFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientStorageClusterCapacityFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientStorageClusterCapacityFault {
+    
+    const filterSensitiveLog: (obj: InsufficientStorageClusterCapacityFault) => any;
+}
+
+export interface InvalidDBSubnetGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBSubnetGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBSubnetGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBSubnetGroupStateFault) => any;
+}
+
+export interface InvalidGlobalClusterStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidGlobalClusterStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidGlobalClusterStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidGlobalClusterStateFault) => any;
+}
+
+export interface InvalidSubnet extends __SmithyException, $MetadataBearer {
+    name: "InvalidSubnet";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidSubnet {
+    
+    const filterSensitiveLog: (obj: InvalidSubnet) => any;
+}
+
+export interface InvalidVPCNetworkStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidVPCNetworkStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidVPCNetworkStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidVPCNetworkStateFault) => any;
+}
+
+export interface StorageQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "StorageQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StorageQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: StorageQuotaExceededFault) => any;
+}
+export interface CreateDBClusterEndpointMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    DBClusterEndpointIdentifier: string | undefined;
+    
+    EndpointType: string | undefined;
+    
+    StaticMembers?: string[];
+    
+    ExcludedMembers?: string[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBClusterEndpointMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterEndpointMessage) => any;
+}
+
+export interface DBClusterEndpoint {
+    
+    DBClusterEndpointIdentifier?: string;
+    
+    DBClusterIdentifier?: string;
+    
+    DBClusterEndpointResourceIdentifier?: string;
+    
+    Endpoint?: string;
+    
+    Status?: string;
+    
+    EndpointType?: string;
+    
+    CustomEndpointType?: string;
+    
+    StaticMembers?: string[];
+    
+    ExcludedMembers?: string[];
+    
+    DBClusterEndpointArn?: string;
+}
+export declare namespace DBClusterEndpoint {
+    
+    const filterSensitiveLog: (obj: DBClusterEndpoint) => any;
+}
+
+export interface DBClusterEndpointAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterEndpointAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterEndpointAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBClusterEndpointAlreadyExistsFault) => any;
+}
+
+export interface DBClusterEndpointQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterEndpointQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterEndpointQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBClusterEndpointQuotaExceededFault) => any;
+}
+
+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 interface AuthorizationNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "AuthorizationNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AuthorizationNotFoundFault {
+    
+    const filterSensitiveLog: (obj: AuthorizationNotFoundFault) => any;
+}
+export interface BackupPolicyNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "BackupPolicyNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace BackupPolicyNotFoundFault {
+    
+    const filterSensitiveLog: (obj: BackupPolicyNotFoundFault) => any;
+}
+
+export interface CreateDBInstanceMessage {
+    
+    DBName?: string;
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    AllocatedStorage?: number;
+    
+    DBInstanceClass: string | undefined;
+    
+    Engine: string | undefined;
+    
+    MasterUsername?: string;
+    
+    MasterUserPassword?: string;
+    
+    DBSecurityGroups?: string[];
+    
+    VpcSecurityGroupIds?: string[];
+    
+    AvailabilityZone?: string;
+    
+    DBSubnetGroupName?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    DBParameterGroupName?: string;
+    
+    BackupRetentionPeriod?: number;
+    
+    PreferredBackupWindow?: string;
+    
+    Port?: number;
+    
+    MultiAZ?: boolean;
+    
+    EngineVersion?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    CharacterSetName?: string;
+    
+    NcharCharacterSetName?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    Tags?: Tag[];
+    
+    DBClusterIdentifier?: string;
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    TdeCredentialPassword?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    Domain?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    PromotionTier?: number;
+    
+    Timezone?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    DeletionProtection?: boolean;
+    
+    MaxAllocatedStorage?: number;
+    
+    EnableCustomerOwnedIp?: boolean;
+}
+export declare namespace CreateDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceMessage) => any;
+}
+
+export interface DBInstanceRole {
+    
+    RoleArn?: string;
+    
+    FeatureName?: string;
+    
+    Status?: string;
+}
+export declare namespace DBInstanceRole {
+    
+    const filterSensitiveLog: (obj: DBInstanceRole) => any;
+}
+
+export interface DBInstanceAutomatedBackupsReplication {
+    
+    DBInstanceAutomatedBackupsArn?: string;
+}
+export declare namespace DBInstanceAutomatedBackupsReplication {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackupsReplication) => any;
+}
+
+export interface DBParameterGroupStatus {
+    
+    DBParameterGroupName?: string;
+    
+    ParameterApplyStatus?: string;
+}
+export declare namespace DBParameterGroupStatus {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupStatus) => any;
+}
+
+export interface AvailabilityZone {
+    
+    Name?: string;
+}
+export declare namespace AvailabilityZone {
+    
+    const filterSensitiveLog: (obj: AvailabilityZone) => any;
+}
+
+export interface Outpost {
+    
+    Arn?: string;
+}
+export declare namespace Outpost {
+    
+    const filterSensitiveLog: (obj: Outpost) => any;
+}
+
+export interface Subnet {
+    
+    SubnetIdentifier?: string;
+    
+    SubnetAvailabilityZone?: AvailabilityZone;
+    
+    SubnetOutpost?: Outpost;
+    
+    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 OptionGroupMembership {
+    
+    OptionGroupName?: string;
+    
+    Status?: string;
+}
+export declare namespace OptionGroupMembership {
+    
+    const filterSensitiveLog: (obj: OptionGroupMembership) => 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;
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+}
+export declare namespace PendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: PendingModifiedValues) => any;
+}
+export declare enum ReplicaMode {
+    MOUNTED = "mounted",
+    OPEN_READ_ONLY = "open-read-only"
+}
+
+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;
+    
+    AutomaticRestartTime?: Date;
+    
+    MasterUsername?: string;
+    
+    DBName?: string;
+    
+    Endpoint?: Endpoint;
+    
+    AllocatedStorage?: number;
+    
+    InstanceCreateTime?: Date;
+    
+    PreferredBackupWindow?: string;
+    
+    BackupRetentionPeriod?: number;
+    
+    DBSecurityGroups?: DBSecurityGroupMembership[];
+    
+    VpcSecurityGroups?: VpcSecurityGroupMembership[];
+    
+    DBParameterGroups?: DBParameterGroupStatus[];
+    
+    AvailabilityZone?: string;
+    
+    DBSubnetGroup?: DBSubnetGroup;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    PendingModifiedValues?: PendingModifiedValues;
+    
+    LatestRestorableTime?: Date;
+    
+    MultiAZ?: boolean;
+    
+    EngineVersion?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    ReadReplicaSourceDBInstanceIdentifier?: string;
+    
+    ReadReplicaDBInstanceIdentifiers?: string[];
+    
+    ReadReplicaDBClusterIdentifiers?: string[];
+    
+    ReplicaMode?: ReplicaMode | string;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    OptionGroupMemberships?: OptionGroupMembership[];
+    
+    CharacterSetName?: string;
+    
+    NcharCharacterSetName?: string;
+    
+    SecondaryAvailabilityZone?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    StatusInfos?: DBInstanceStatusInfo[];
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    DbInstancePort?: number;
+    
+    DBClusterIdentifier?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    DbiResourceId?: string;
+    
+    CACertificateIdentifier?: string;
+    
+    DomainMemberships?: DomainMembership[];
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    EnhancedMonitoringResourceArn?: string;
+    
+    MonitoringRoleArn?: string;
+    
+    PromotionTier?: number;
+    
+    DBInstanceArn?: string;
+    
+    Timezone?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    PerformanceInsightsEnabled?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    EnabledCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    DeletionProtection?: boolean;
+    
+    AssociatedRoles?: DBInstanceRole[];
+    
+    ListenerEndpoint?: Endpoint;
+    
+    MaxAllocatedStorage?: number;
+    
+    TagList?: Tag[];
+    
+    DBInstanceAutomatedBackupsReplications?: DBInstanceAutomatedBackupsReplication[];
+    
+    CustomerOwnedIpEnabled?: boolean;
+    
+    AwsBackupRecoveryPointArn?: string;
+    
+    ActivityStreamStatus?: ActivityStreamStatus | string;
+    
+    ActivityStreamKmsKeyId?: string;
+    
+    ActivityStreamKinesisStreamName?: string;
+    
+    ActivityStreamMode?: ActivityStreamMode | string;
+    
+    ActivityStreamEngineNativeAuditFieldsIncluded?: boolean;
+}
+export declare namespace DBInstance {
+    
+    const filterSensitiveLog: (obj: DBInstance) => any;
+}
+export interface CreateDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace CreateDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceResult) => any;
+}
+
+export interface DBInstanceAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceAlreadyExistsFault) => any;
+}
+
+export interface InstanceQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "InstanceQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InstanceQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: InstanceQuotaExceededFault) => any;
+}
+
+export interface InsufficientDBInstanceCapacityFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientDBInstanceCapacityFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientDBInstanceCapacityFault {
+    
+    const filterSensitiveLog: (obj: InsufficientDBInstanceCapacityFault) => any;
+}
+
+export interface ProvisionedIopsNotAvailableInAZFault extends __SmithyException, $MetadataBearer {
+    name: "ProvisionedIopsNotAvailableInAZFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ProvisionedIopsNotAvailableInAZFault {
+    
+    const filterSensitiveLog: (obj: ProvisionedIopsNotAvailableInAZFault) => any;
+}
+
+export interface StorageTypeNotSupportedFault extends __SmithyException, $MetadataBearer {
+    name: "StorageTypeNotSupportedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace StorageTypeNotSupportedFault {
+    
+    const filterSensitiveLog: (obj: StorageTypeNotSupportedFault) => any;
+}
+export interface CreateDBInstanceReadReplicaMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    SourceDBInstanceIdentifier: string | undefined;
+    
+    DBInstanceClass?: string;
+    
+    AvailabilityZone?: string;
+    
+    Port?: number;
+    
+    MultiAZ?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    DBParameterGroupName?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    Tags?: Tag[];
+    
+    DBSubnetGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    StorageType?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    UseDefaultProcessorFeatures?: boolean;
+    
+    DeletionProtection?: boolean;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    ReplicaMode?: ReplicaMode | string;
+    
+    MaxAllocatedStorage?: number;
+}
+export declare namespace CreateDBInstanceReadReplicaMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceReadReplicaMessage) => any;
+}
+export interface CreateDBInstanceReadReplicaResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace CreateDBInstanceReadReplicaResult {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceReadReplicaResult) => any;
+}
+
+export interface DBSubnetGroupNotAllowedFault extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetGroupNotAllowedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetGroupNotAllowedFault {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupNotAllowedFault) => any;
+}
+
+export interface InvalidDBSubnetGroupFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBSubnetGroupFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBSubnetGroupFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBSubnetGroupFault) => any;
+}
+
+export interface CreateDBParameterGroupMessage {
+    
+    DBParameterGroupName: string | undefined;
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Description: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBParameterGroupMessage) => any;
+}
+export interface CreateDBParameterGroupResult {
+    
+    DBParameterGroup?: DBParameterGroup;
+}
+export declare namespace CreateDBParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateDBParameterGroupResult) => any;
+}
+export declare enum AuthScheme {
+    SECRETS = "SECRETS"
+}
+export declare enum IAMAuthMode {
+    DISABLED = "DISABLED",
+    REQUIRED = "REQUIRED"
+}
+
+export interface UserAuthConfig {
+    
+    Description?: string;
+    
+    UserName?: string;
+    
+    AuthScheme?: AuthScheme | string;
+    
+    SecretArn?: string;
+    
+    IAMAuth?: IAMAuthMode | string;
+}
+export declare namespace UserAuthConfig {
+    
+    const filterSensitiveLog: (obj: UserAuthConfig) => any;
+}
+export declare enum EngineFamily {
+    MYSQL = "MYSQL",
+    POSTGRESQL = "POSTGRESQL"
+}
+export interface CreateDBProxyRequest {
+    
+    DBProxyName: string | undefined;
+    
+    EngineFamily: EngineFamily | string | undefined;
+    
+    Auth: UserAuthConfig[] | undefined;
+    
+    RoleArn: string | undefined;
+    
+    VpcSubnetIds: string[] | undefined;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    RequireTLS?: boolean;
+    
+    IdleClientTimeout?: number;
+    
+    DebugLogging?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBProxyRequest {
+    
+    const filterSensitiveLog: (obj: CreateDBProxyRequest) => any;
+}
+
+export interface UserAuthConfigInfo {
+    
+    Description?: string;
+    
+    UserName?: string;
+    
+    AuthScheme?: AuthScheme | string;
+    
+    SecretArn?: string;
+    
+    IAMAuth?: IAMAuthMode | string;
+}
+export declare namespace UserAuthConfigInfo {
+    
+    const filterSensitiveLog: (obj: UserAuthConfigInfo) => any;
+}
+export declare enum DBProxyStatus {
+    AVAILABLE = "available",
+    CREATING = "creating",
+    DELETING = "deleting",
+    INCOMPATIBLE_NETWORK = "incompatible-network",
+    INSUFFICIENT_RESOURCE_LIMITS = "insufficient-resource-limits",
+    MODIFYING = "modifying",
+    REACTIVATING = "reactivating",
+    SUSPENDED = "suspended",
+    SUSPENDING = "suspending"
+}
+
+export interface DBProxy {
+    
+    DBProxyName?: string;
+    
+    DBProxyArn?: string;
+    
+    Status?: DBProxyStatus | string;
+    
+    EngineFamily?: string;
+    
+    VpcId?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    VpcSubnetIds?: string[];
+    
+    Auth?: UserAuthConfigInfo[];
+    
+    RoleArn?: string;
+    
+    Endpoint?: string;
+    
+    RequireTLS?: boolean;
+    
+    IdleClientTimeout?: number;
+    
+    DebugLogging?: boolean;
+    
+    CreatedDate?: Date;
+    
+    UpdatedDate?: Date;
+}
+export declare namespace DBProxy {
+    
+    const filterSensitiveLog: (obj: DBProxy) => any;
+}
+export interface CreateDBProxyResponse {
+    
+    DBProxy?: DBProxy;
+}
+export declare namespace CreateDBProxyResponse {
+    
+    const filterSensitiveLog: (obj: CreateDBProxyResponse) => any;
+}
+
+export interface DBProxyAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBProxyAlreadyExistsFault) => any;
+}
+
+export interface DBProxyQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBProxyQuotaExceededFault) => any;
+}
+export declare enum DBProxyEndpointTargetRole {
+    READ_ONLY = "READ_ONLY",
+    READ_WRITE = "READ_WRITE"
+}
+export interface CreateDBProxyEndpointRequest {
+    
+    DBProxyName: string | undefined;
+    
+    DBProxyEndpointName: string | undefined;
+    
+    VpcSubnetIds: string[] | undefined;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    TargetRole?: DBProxyEndpointTargetRole | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBProxyEndpointRequest {
+    
+    const filterSensitiveLog: (obj: CreateDBProxyEndpointRequest) => any;
+}
+export declare enum DBProxyEndpointStatus {
+    AVAILABLE = "available",
+    CREATING = "creating",
+    DELETING = "deleting",
+    INCOMPATIBLE_NETWORK = "incompatible-network",
+    INSUFFICIENT_RESOURCE_LIMITS = "insufficient-resource-limits",
+    MODIFYING = "modifying"
+}
+
+export interface DBProxyEndpoint {
+    
+    DBProxyEndpointName?: string;
+    
+    DBProxyEndpointArn?: string;
+    
+    DBProxyName?: string;
+    
+    Status?: DBProxyEndpointStatus | string;
+    
+    VpcId?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    VpcSubnetIds?: string[];
+    
+    Endpoint?: string;
+    
+    CreatedDate?: Date;
+    
+    TargetRole?: DBProxyEndpointTargetRole | string;
+    
+    IsDefault?: boolean;
+}
+export declare namespace DBProxyEndpoint {
+    
+    const filterSensitiveLog: (obj: DBProxyEndpoint) => any;
+}
+export interface CreateDBProxyEndpointResponse {
+    
+    DBProxyEndpoint?: DBProxyEndpoint;
+}
+export declare namespace CreateDBProxyEndpointResponse {
+    
+    const filterSensitiveLog: (obj: CreateDBProxyEndpointResponse) => any;
+}
+
+export interface DBProxyEndpointAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyEndpointAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyEndpointAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBProxyEndpointAlreadyExistsFault) => any;
+}
+
+export interface DBProxyEndpointQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyEndpointQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyEndpointQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBProxyEndpointQuotaExceededFault) => any;
+}
+
+export interface InvalidDBProxyStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBProxyStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBProxyStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBProxyStateFault) => any;
+}
+
+export interface CreateDBSecurityGroupMessage {
+    
+    DBSecurityGroupName: string | undefined;
+    
+    DBSecurityGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBSecurityGroupMessage) => any;
+}
+export interface CreateDBSecurityGroupResult {
+    
+    DBSecurityGroup?: DBSecurityGroup;
+}
+export declare namespace CreateDBSecurityGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateDBSecurityGroupResult) => any;
+}
+
+export interface DBSecurityGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBSecurityGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSecurityGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupAlreadyExistsFault) => any;
+}
+
+export interface DBSecurityGroupNotSupportedFault extends __SmithyException, $MetadataBearer {
+    name: "DBSecurityGroupNotSupportedFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSecurityGroupNotSupportedFault {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupNotSupportedFault) => any;
+}
+
+export interface DBSecurityGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBSecurityGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSecurityGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupQuotaExceededFault) => any;
+}
+
+export interface CreateDBSnapshotMessage {
+    
+    DBSnapshotIdentifier: string | undefined;
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBSnapshotMessage) => any;
+}
+export interface CreateDBSnapshotResult {
+    
+    DBSnapshot?: DBSnapshot;
+}
+export declare namespace CreateDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CreateDBSnapshotResult) => any;
+}
+
+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 interface DBSubnetGroupAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetGroupAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetGroupAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupAlreadyExistsFault) => any;
+}
+
+export interface DBSubnetGroupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetGroupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetGroupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupQuotaExceededFault) => any;
+}
+
+export interface DBSubnetQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBSubnetQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBSubnetQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBSubnetQuotaExceededFault) => any;
+}
+
+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 interface EventSubscriptionQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "EventSubscriptionQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EventSubscriptionQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: EventSubscriptionQuotaExceededFault) => any;
+}
+
+export interface SNSInvalidTopicFault extends __SmithyException, $MetadataBearer {
+    name: "SNSInvalidTopicFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSInvalidTopicFault {
+    
+    const filterSensitiveLog: (obj: SNSInvalidTopicFault) => any;
+}
+
+export interface SNSNoAuthorizationFault extends __SmithyException, $MetadataBearer {
+    name: "SNSNoAuthorizationFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSNoAuthorizationFault {
+    
+    const filterSensitiveLog: (obj: SNSNoAuthorizationFault) => any;
+}
+
+export interface SNSTopicArnNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SNSTopicArnNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SNSTopicArnNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SNSTopicArnNotFoundFault) => any;
+}
+
+export interface SubscriptionAlreadyExistFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionAlreadyExistFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionAlreadyExistFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionAlreadyExistFault) => any;
+}
+
+export interface SubscriptionCategoryNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "SubscriptionCategoryNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubscriptionCategoryNotFoundFault {
+    
+    const filterSensitiveLog: (obj: SubscriptionCategoryNotFoundFault) => any;
+}
+export interface CreateGlobalClusterMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    SourceDBClusterIdentifier?: string;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DeletionProtection?: boolean;
+    
+    DatabaseName?: string;
+    
+    StorageEncrypted?: boolean;
+}
+export declare namespace CreateGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: CreateGlobalClusterMessage) => any;
+}
+export declare enum FailoverStatus {
+    CANCELLING = "cancelling",
+    FAILING_OVER = "failing-over",
+    PENDING = "pending"
+}
+
+export interface FailoverState {
+    
+    Status?: FailoverStatus | string;
+    
+    FromDbClusterArn?: string;
+    
+    ToDbClusterArn?: string;
+}
+export declare namespace FailoverState {
+    
+    const filterSensitiveLog: (obj: FailoverState) => any;
+}
+
+export interface GlobalClusterMember {
+    
+    DBClusterArn?: string;
+    
+    Readers?: string[];
+    
+    IsWriter?: boolean;
+    
+    GlobalWriteForwardingStatus?: WriteForwardingStatus | string;
+}
+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[];
+    
+    FailoverState?: FailoverState;
+}
+export declare namespace GlobalCluster {
+    
+    const filterSensitiveLog: (obj: GlobalCluster) => any;
+}
+export interface CreateGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace CreateGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateGlobalClusterResult) => any;
+}
+
+export interface GlobalClusterAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "GlobalClusterAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace GlobalClusterAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: GlobalClusterAlreadyExistsFault) => any;
+}
+
+export interface GlobalClusterQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "GlobalClusterQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace GlobalClusterQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: GlobalClusterQuotaExceededFault) => any;
+}
+
+export interface CreateOptionGroupMessage {
+    
+    OptionGroupName: string | undefined;
+    
+    EngineName: string | undefined;
+    
+    MajorEngineVersion: string | undefined;
+    
+    OptionGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateOptionGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateOptionGroupMessage) => any;
+}
+export interface CreateOptionGroupResult {
+    
+    OptionGroup?: OptionGroup;
+}
+export declare namespace CreateOptionGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateOptionGroupResult) => any;
+}
+export interface DeleteCustomAvailabilityZoneMessage {
+    
+    CustomAvailabilityZoneId: string | undefined;
+}
+export declare namespace DeleteCustomAvailabilityZoneMessage {
+    
+    const filterSensitiveLog: (obj: DeleteCustomAvailabilityZoneMessage) => any;
+}
+export interface DeleteCustomAvailabilityZoneResult {
+    
+    CustomAvailabilityZone?: CustomAvailabilityZone;
+}
+export declare namespace DeleteCustomAvailabilityZoneResult {
+    
+    const filterSensitiveLog: (obj: DeleteCustomAvailabilityZoneResult) => any;
+}
+
+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 DBClusterEndpointNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterEndpointNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterEndpointNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterEndpointNotFoundFault) => any;
+}
+export interface DeleteDBClusterEndpointMessage {
+    
+    DBClusterEndpointIdentifier: string | undefined;
+}
+export declare namespace DeleteDBClusterEndpointMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterEndpointMessage) => any;
+}
+
+export interface InvalidDBClusterEndpointStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBClusterEndpointStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBClusterEndpointStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBClusterEndpointStateFault) => any;
+}
+
+export interface DeleteDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+}
+export declare namespace DeleteDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterParameterGroupMessage) => any;
+}
+
+export interface InvalidDBParameterGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBParameterGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBParameterGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBParameterGroupStateFault) => any;
+}
+
+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 interface DBInstanceAutomatedBackupQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceAutomatedBackupQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceAutomatedBackupQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackupQuotaExceededFault) => any;
+}
+
+export interface DeleteDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    SkipFinalSnapshot?: boolean;
+    
+    FinalDBSnapshotIdentifier?: string;
+    
+    DeleteAutomatedBackups?: boolean;
+}
+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 DBInstanceAutomatedBackupNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceAutomatedBackupNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceAutomatedBackupNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackupNotFoundFault) => any;
+}
+
+export interface DeleteDBInstanceAutomatedBackupMessage {
+    
+    DbiResourceId?: string;
+    
+    DBInstanceAutomatedBackupsArn?: string;
+}
+export declare namespace DeleteDBInstanceAutomatedBackupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBInstanceAutomatedBackupMessage) => any;
+}
+
+export interface RestoreWindow {
+    
+    EarliestTime?: Date;
+    
+    LatestTime?: Date;
+}
+export declare namespace RestoreWindow {
+    
+    const filterSensitiveLog: (obj: RestoreWindow) => any;
+}
+
+export interface DBInstanceAutomatedBackup {
+    
+    DBInstanceArn?: string;
+    
+    DbiResourceId?: string;
+    
+    Region?: string;
+    
+    DBInstanceIdentifier?: string;
+    
+    RestoreWindow?: RestoreWindow;
+    
+    AllocatedStorage?: number;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    VpcId?: string;
+    
+    InstanceCreateTime?: Date;
+    
+    MasterUsername?: string;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    TdeCredentialArn?: string;
+    
+    Encrypted?: boolean;
+    
+    StorageType?: string;
+    
+    KmsKeyId?: string;
+    
+    Timezone?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    BackupRetentionPeriod?: number;
+    
+    DBInstanceAutomatedBackupsArn?: string;
+    
+    DBInstanceAutomatedBackupsReplications?: DBInstanceAutomatedBackupsReplication[];
+}
+export declare namespace DBInstanceAutomatedBackup {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackup) => any;
+}
+export interface DeleteDBInstanceAutomatedBackupResult {
+    
+    DBInstanceAutomatedBackup?: DBInstanceAutomatedBackup;
+}
+export declare namespace DeleteDBInstanceAutomatedBackupResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBInstanceAutomatedBackupResult) => any;
+}
+
+export interface InvalidDBInstanceAutomatedBackupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBInstanceAutomatedBackupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBInstanceAutomatedBackupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBInstanceAutomatedBackupStateFault) => any;
+}
+
+export interface DeleteDBParameterGroupMessage {
+    
+    DBParameterGroupName: string | undefined;
+}
+export declare namespace DeleteDBParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBParameterGroupMessage) => any;
+}
+export interface DeleteDBProxyRequest {
+    
+    DBProxyName: string | undefined;
+}
+export declare namespace DeleteDBProxyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDBProxyRequest) => any;
+}
+export interface DeleteDBProxyResponse {
+    
+    DBProxy?: DBProxy;
+}
+export declare namespace DeleteDBProxyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDBProxyResponse) => any;
+}
+
+export interface DBProxyEndpointNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyEndpointNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyEndpointNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBProxyEndpointNotFoundFault) => any;
+}
+export interface DeleteDBProxyEndpointRequest {
+    
+    DBProxyEndpointName: string | undefined;
+}
+export declare namespace DeleteDBProxyEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDBProxyEndpointRequest) => any;
+}
+export interface DeleteDBProxyEndpointResponse {
+    
+    DBProxyEndpoint?: DBProxyEndpoint;
+}
+export declare namespace DeleteDBProxyEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDBProxyEndpointResponse) => any;
+}
+
+export interface InvalidDBProxyEndpointStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBProxyEndpointStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBProxyEndpointStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBProxyEndpointStateFault) => any;
+}
+
+export interface DeleteDBSecurityGroupMessage {
+    
+    DBSecurityGroupName: string | undefined;
+}
+export declare namespace DeleteDBSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBSecurityGroupMessage) => any;
+}
+
+export interface DeleteDBSnapshotMessage {
+    
+    DBSnapshotIdentifier: string | undefined;
+}
+export declare namespace DeleteDBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBSnapshotMessage) => any;
+}
+export interface DeleteDBSnapshotResult {
+    
+    DBSnapshot?: DBSnapshot;
+}
+export declare namespace DeleteDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBSnapshotResult) => any;
+}
+
+export interface DeleteDBSubnetGroupMessage {
+    
+    DBSubnetGroupName: string | undefined;
+}
+export declare namespace DeleteDBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBSubnetGroupMessage) => any;
+}
+
+export interface InvalidDBSubnetStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBSubnetStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBSubnetStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBSubnetStateFault) => any;
+}
+
+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 interface InvalidEventSubscriptionStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidEventSubscriptionStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidEventSubscriptionStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidEventSubscriptionStateFault) => any;
+}
+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 DeleteInstallationMediaMessage {
+    
+    InstallationMediaId: string | undefined;
+}
+export declare namespace DeleteInstallationMediaMessage {
+    
+    const filterSensitiveLog: (obj: DeleteInstallationMediaMessage) => any;
+}
+
+export interface InstallationMediaFailureCause {
+    
+    Message?: string;
+}
+export declare namespace InstallationMediaFailureCause {
+    
+    const filterSensitiveLog: (obj: InstallationMediaFailureCause) => any;
+}
+
+export interface InstallationMedia {
+    
+    InstallationMediaId?: string;
+    
+    CustomAvailabilityZoneId?: string;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    EngineInstallationMediaPath?: string;
+    
+    OSInstallationMediaPath?: string;
+    
+    Status?: string;
+    
+    FailureCause?: InstallationMediaFailureCause;
+}
+export declare namespace InstallationMedia {
+    
+    const filterSensitiveLog: (obj: InstallationMedia) => any;
+}
+
+export interface InstallationMediaNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "InstallationMediaNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InstallationMediaNotFoundFault {
+    
+    const filterSensitiveLog: (obj: InstallationMediaNotFoundFault) => any;
+}
+
+export interface DeleteOptionGroupMessage {
+    
+    OptionGroupName: string | undefined;
+}
+export declare namespace DeleteOptionGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteOptionGroupMessage) => any;
+}
+
+export interface InvalidOptionGroupStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidOptionGroupStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidOptionGroupStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidOptionGroupStateFault) => any;
+}
+
+export interface DBProxyTargetNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyTargetNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyTargetNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBProxyTargetNotFoundFault) => any;
+}
+export interface DeregisterDBProxyTargetsRequest {
+    
+    DBProxyName: string | undefined;
+    
+    TargetGroupName?: string;
+    
+    DBInstanceIdentifiers?: string[];
+    
+    DBClusterIdentifiers?: string[];
+}
+export declare namespace DeregisterDBProxyTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterDBProxyTargetsRequest) => any;
+}
+export interface DeregisterDBProxyTargetsResponse {
+}
+export declare namespace DeregisterDBProxyTargetsResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterDBProxyTargetsResponse) => any;
+}
+
+export interface DescribeAccountAttributesMessage {
+}
+export declare namespace DescribeAccountAttributesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeAccountAttributesMessage) => any;
+}
+
+export interface Certificate {
+    
+    CertificateIdentifier?: string;
+    
+    CertificateType?: string;
+    
+    Thumbprint?: string;
+    
+    ValidFrom?: Date;
+    
+    ValidTill?: Date;
+    
+    CertificateArn?: string;
+    
+    CustomerOverride?: boolean;
+    
+    CustomerOverrideValidTill?: Date;
+}
+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 interface CertificateNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "CertificateNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CertificateNotFoundFault {
+    
+    const filterSensitiveLog: (obj: CertificateNotFoundFault) => any;
+}
+
+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 CustomAvailabilityZoneMessage {
+    
+    Marker?: string;
+    
+    CustomAvailabilityZones?: CustomAvailabilityZone[];
+}
+export declare namespace CustomAvailabilityZoneMessage {
+    
+    const filterSensitiveLog: (obj: CustomAvailabilityZoneMessage) => any;
+}
+export interface DescribeCustomAvailabilityZonesMessage {
+    
+    CustomAvailabilityZoneId?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeCustomAvailabilityZonesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeCustomAvailabilityZonesMessage) => any;
+}
+
+export interface DBClusterBacktrackMessage {
+    
+    Marker?: string;
+    
+    DBClusterBacktracks?: DBClusterBacktrack[];
+}
+export declare namespace DBClusterBacktrackMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterBacktrackMessage) => any;
+}
+
+export interface DBClusterBacktrackNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterBacktrackNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterBacktrackNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterBacktrackNotFoundFault) => any;
+}
+
+export interface DescribeDBClusterBacktracksMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    BacktrackIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBClusterBacktracksMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterBacktracksMessage) => any;
+}
+export interface DBClusterEndpointMessage {
+    
+    Marker?: string;
+    
+    DBClusterEndpoints?: DBClusterEndpoint[];
+}
+export declare namespace DBClusterEndpointMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterEndpointMessage) => any;
+}
+export interface DescribeDBClusterEndpointsMessage {
+    
+    DBClusterIdentifier?: string;
+    
+    DBClusterEndpointIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBClusterEndpointsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBClusterEndpointsMessage) => 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;
+    
+    SupportedEngineModes?: 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;
+    
+    IncludeShared?: boolean;
+}
+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 CharacterSet {
+    
+    CharacterSetName?: string;
+    
+    CharacterSetDescription?: string;
+}
+export declare namespace CharacterSet {
+    
+    const filterSensitiveLog: (obj: CharacterSet) => any;
+}
+
+export interface Timezone {
+    
+    TimezoneName?: string;
+}
+export declare namespace Timezone {
+    
+    const filterSensitiveLog: (obj: Timezone) => any;
+}
+
+export interface UpgradeTarget {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    Description?: string;
+    
+    AutoUpgrade?: boolean;
+    
+    IsMajorVersionUpgrade?: boolean;
+    
+    SupportedEngineModes?: string[];
+    
+    SupportsParallelQuery?: boolean;
+    
+    SupportsGlobalDatabases?: boolean;
+}
+export declare namespace UpgradeTarget {
+    
+    const filterSensitiveLog: (obj: UpgradeTarget) => any;
+}
+
+export interface DBEngineVersion {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    DBEngineDescription?: string;
+    
+    DBEngineVersionDescription?: string;
+    
+    DefaultCharacterSet?: CharacterSet;
+    
+    SupportedCharacterSets?: CharacterSet[];
+    
+    SupportedNcharCharacterSets?: CharacterSet[];
+    
+    ValidUpgradeTarget?: UpgradeTarget[];
+    
+    SupportedTimezones?: Timezone[];
+    
+    ExportableLogTypes?: string[];
+    
+    SupportsLogExportsToCloudwatchLogs?: boolean;
+    
+    SupportsReadReplica?: boolean;
+    
+    SupportedEngineModes?: string[];
+    
+    SupportedFeatureNames?: string[];
+    
+    Status?: string;
+    
+    SupportsParallelQuery?: boolean;
+    
+    SupportsGlobalDatabases?: 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;
+    
+    IncludeAll?: boolean;
+}
+export declare namespace DescribeDBEngineVersionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBEngineVersionsMessage) => any;
+}
+
+export interface DBInstanceAutomatedBackupMessage {
+    
+    Marker?: string;
+    
+    DBInstanceAutomatedBackups?: DBInstanceAutomatedBackup[];
+}
+export declare namespace DBInstanceAutomatedBackupMessage {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackupMessage) => any;
+}
+
+export interface DescribeDBInstanceAutomatedBackupsMessage {
+    
+    DbiResourceId?: string;
+    
+    DBInstanceIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    DBInstanceAutomatedBackupsArn?: string;
+}
+export declare namespace DescribeDBInstanceAutomatedBackupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBInstanceAutomatedBackupsMessage) => 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 DescribeDBLogFilesMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    FilenameContains?: string;
+    
+    FileLastWritten?: number;
+    
+    FileSize?: number;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBLogFilesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBLogFilesMessage) => any;
+}
+
+export interface DescribeDBLogFilesDetails {
+    
+    LogFileName?: string;
+    
+    LastWritten?: number;
+    
+    Size?: number;
+}
+export declare namespace DescribeDBLogFilesDetails {
+    
+    const filterSensitiveLog: (obj: DescribeDBLogFilesDetails) => any;
+}
+
+export interface DescribeDBLogFilesResponse {
+    
+    DescribeDBLogFiles?: DescribeDBLogFilesDetails[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBLogFilesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBLogFilesResponse) => any;
+}
+
+export interface DBParameterGroupsMessage {
+    
+    Marker?: string;
+    
+    DBParameterGroups?: DBParameterGroup[];
+}
+export declare namespace DBParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupsMessage) => any;
+}
+
+export interface DescribeDBParameterGroupsMessage {
+    
+    DBParameterGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBParameterGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBParameterGroupsMessage) => any;
+}
+
+export interface DBParameterGroupDetails {
+    
+    Parameters?: Parameter[];
+    
+    Marker?: string;
+}
+export declare namespace DBParameterGroupDetails {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupDetails) => any;
+}
+export interface DescribeDBParametersMessage {
+    
+    DBParameterGroupName: string | undefined;
+    
+    Source?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBParametersMessage) => any;
+}
+export interface DescribeDBProxiesRequest {
+    
+    DBProxyName?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeDBProxiesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxiesRequest) => any;
+}
+export interface DescribeDBProxiesResponse {
+    
+    DBProxies?: DBProxy[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBProxiesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxiesResponse) => any;
+}
+export interface DescribeDBProxyEndpointsRequest {
+    
+    DBProxyName?: string;
+    
+    DBProxyEndpointName?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeDBProxyEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyEndpointsRequest) => any;
+}
+export interface DescribeDBProxyEndpointsResponse {
+    
+    DBProxyEndpoints?: DBProxyEndpoint[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBProxyEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyEndpointsResponse) => any;
+}
+export interface DescribeDBProxyTargetGroupsRequest {
+    
+    DBProxyName: string | undefined;
+    
+    TargetGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeDBProxyTargetGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyTargetGroupsRequest) => any;
+}
+
+export interface ConnectionPoolConfigurationInfo {
+    
+    MaxConnectionsPercent?: number;
+    
+    MaxIdleConnectionsPercent?: number;
+    
+    ConnectionBorrowTimeout?: number;
+    
+    SessionPinningFilters?: string[];
+    
+    InitQuery?: string;
+}
+export declare namespace ConnectionPoolConfigurationInfo {
+    
+    const filterSensitiveLog: (obj: ConnectionPoolConfigurationInfo) => any;
+}
+
+export interface DBProxyTargetGroup {
+    
+    DBProxyName?: string;
+    
+    TargetGroupName?: string;
+    
+    TargetGroupArn?: string;
+    
+    IsDefault?: boolean;
+    
+    Status?: string;
+    
+    ConnectionPoolConfig?: ConnectionPoolConfigurationInfo;
+    
+    CreatedDate?: Date;
+    
+    UpdatedDate?: Date;
+}
+export declare namespace DBProxyTargetGroup {
+    
+    const filterSensitiveLog: (obj: DBProxyTargetGroup) => any;
+}
+export interface DescribeDBProxyTargetGroupsResponse {
+    
+    TargetGroups?: DBProxyTargetGroup[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBProxyTargetGroupsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyTargetGroupsResponse) => any;
+}
+export interface DescribeDBProxyTargetsRequest {
+    
+    DBProxyName: string | undefined;
+    
+    TargetGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeDBProxyTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyTargetsRequest) => any;
+}
+export declare enum TargetRole {
+    READ_ONLY = "READ_ONLY",
+    READ_WRITE = "READ_WRITE",
+    UNKNOWN = "UNKNOWN"
+}
+export declare enum TargetHealthReason {
+    AUTH_FAILURE = "AUTH_FAILURE",
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    INVALID_REPLICATION_STATE = "INVALID_REPLICATION_STATE",
+    PENDING_PROXY_CAPACITY = "PENDING_PROXY_CAPACITY",
+    UNREACHABLE = "UNREACHABLE"
+}
+export declare enum TargetState {
+    available = "AVAILABLE",
+    registering = "REGISTERING",
+    unavailable = "UNAVAILABLE"
+}
+
+export interface TargetHealth {
+    
+    State?: TargetState | string;
+    
+    Reason?: TargetHealthReason | string;
+    
+    Description?: string;
+}
+export declare namespace TargetHealth {
+    
+    const filterSensitiveLog: (obj: TargetHealth) => any;
+}
+export declare enum TargetType {
+    RDS_INSTANCE = "RDS_INSTANCE",
+    RDS_SERVERLESS_ENDPOINT = "RDS_SERVERLESS_ENDPOINT",
+    TRACKED_CLUSTER = "TRACKED_CLUSTER"
+}
+
+export interface DBProxyTarget {
+    
+    TargetArn?: string;
+    
+    Endpoint?: string;
+    
+    TrackedClusterId?: string;
+    
+    RdsResourceId?: string;
+    
+    Port?: number;
+    
+    Type?: TargetType | string;
+    
+    Role?: TargetRole | string;
+    
+    TargetHealth?: TargetHealth;
+}
+export declare namespace DBProxyTarget {
+    
+    const filterSensitiveLog: (obj: DBProxyTarget) => any;
+}
+export interface DescribeDBProxyTargetsResponse {
+    
+    Targets?: DBProxyTarget[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBProxyTargetsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyTargetsResponse) => any;
+}