@aws-sdk/client-rds 3.50.0 → 3.53.0

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

@@ -0,0 +1,4007 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RDSServiceException as __BaseException } from "./RDSServiceException";
+
+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 declare class DBClusterNotFoundFault extends __BaseException {
+    readonly name: "DBClusterNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterNotFoundFault, __BaseException>);
+}
+
+export declare class DBClusterRoleAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterRoleAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterRoleAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterRoleQuotaExceededFault extends __BaseException {
+    readonly name: "DBClusterRoleQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterRoleQuotaExceededFault, __BaseException>);
+}
+
+export declare class InvalidDBClusterStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterStateFault, __BaseException>);
+}
+export interface AddRoleToDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName: string | undefined;
+}
+export declare namespace AddRoleToDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: AddRoleToDBInstanceMessage) => any;
+}
+
+export declare class DBInstanceNotFoundFault extends __BaseException {
+    readonly name: "DBInstanceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceNotFoundFault, __BaseException>);
+}
+
+export declare class DBInstanceRoleAlreadyExistsFault extends __BaseException {
+    readonly name: "DBInstanceRoleAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceRoleAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBInstanceRoleQuotaExceededFault extends __BaseException {
+    readonly name: "DBInstanceRoleQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceRoleQuotaExceededFault, __BaseException>);
+}
+
+export declare class InvalidDBInstanceStateFault extends __BaseException {
+    readonly name: "InvalidDBInstanceStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBInstanceStateFault, __BaseException>);
+}
+
+export interface AddSourceIdentifierToSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SourceIdentifier: string | undefined;
+}
+export declare namespace AddSourceIdentifierToSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: AddSourceIdentifierToSubscriptionMessage) => any;
+}
+
+export interface EventSubscription {
+    
+    CustomerAwsId?: string;
+    
+    CustSubscriptionId?: string;
+    
+    SnsTopicArn?: string;
+    
+    Status?: string;
+    
+    SubscriptionCreationTime?: string;
+    
+    SourceType?: string;
+    
+    SourceIdsList?: string[];
+    
+    EventCategoriesList?: string[];
+    
+    Enabled?: boolean;
+    
+    EventSubscriptionArn?: string;
+}
+export declare namespace EventSubscription {
+    
+    const filterSensitiveLog: (obj: EventSubscription) => any;
+}
+export interface AddSourceIdentifierToSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace AddSourceIdentifierToSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: AddSourceIdentifierToSubscriptionResult) => any;
+}
+
+export declare class SourceNotFoundFault extends __BaseException {
+    readonly name: "SourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionNotFoundFault, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsToResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace AddTagsToResourceMessage {
+    
+    const filterSensitiveLog: (obj: AddTagsToResourceMessage) => any;
+}
+
+export declare class DBProxyNotFoundFault extends __BaseException {
+    readonly name: "DBProxyNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyNotFoundFault, __BaseException>);
+}
+
+export declare class DBProxyTargetGroupNotFoundFault extends __BaseException {
+    readonly name: "DBProxyTargetGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyTargetGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DBSnapshotNotFoundFault extends __BaseException {
+    readonly name: "DBSnapshotNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSnapshotNotFoundFault, __BaseException>);
+}
+
+export interface ApplyPendingMaintenanceActionMessage {
+    
+    ResourceIdentifier: string | undefined;
+    
+    ApplyAction: string | undefined;
+    
+    OptInType: string | undefined;
+}
+export declare namespace ApplyPendingMaintenanceActionMessage {
+    
+    const filterSensitiveLog: (obj: ApplyPendingMaintenanceActionMessage) => any;
+}
+
+export interface PendingMaintenanceAction {
+    
+    Action?: string;
+    
+    AutoAppliedAfterDate?: Date;
+    
+    ForcedApplyDate?: Date;
+    
+    OptInStatus?: string;
+    
+    CurrentApplyDate?: Date;
+    
+    Description?: string;
+}
+export declare namespace PendingMaintenanceAction {
+    
+    const filterSensitiveLog: (obj: PendingMaintenanceAction) => any;
+}
+
+export interface ResourcePendingMaintenanceActions {
+    
+    ResourceIdentifier?: string;
+    
+    PendingMaintenanceActionDetails?: PendingMaintenanceAction[];
+}
+export declare namespace ResourcePendingMaintenanceActions {
+    
+    const filterSensitiveLog: (obj: ResourcePendingMaintenanceActions) => any;
+}
+export interface ApplyPendingMaintenanceActionResult {
+    
+    ResourcePendingMaintenanceActions?: ResourcePendingMaintenanceActions;
+}
+export declare namespace ApplyPendingMaintenanceActionResult {
+    
+    const filterSensitiveLog: (obj: ApplyPendingMaintenanceActionResult) => any;
+}
+
+export declare class ResourceNotFoundFault extends __BaseException {
+    readonly name: "ResourceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundFault, __BaseException>);
+}
+
+export declare class AuthorizationAlreadyExistsFault extends __BaseException {
+    readonly name: "AuthorizationAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationAlreadyExistsFault, __BaseException>);
+}
+
+export declare class AuthorizationQuotaExceededFault extends __BaseException {
+    readonly name: "AuthorizationQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationQuotaExceededFault, __BaseException>);
+}
+
+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 declare class DBSecurityGroupNotFoundFault extends __BaseException {
+    readonly name: "DBSecurityGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidDBSecurityGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBSecurityGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSecurityGroupStateFault, __BaseException>);
+}
+
+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 declare class ExportTaskNotFoundFault extends __BaseException {
+    readonly name: "ExportTaskNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ExportTaskNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidExportTaskStateFault extends __BaseException {
+    readonly name: "InvalidExportTaskStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidExportTaskStateFault, __BaseException>);
+}
+export interface CopyDBClusterParameterGroupMessage {
+    
+    SourceDBClusterParameterGroupIdentifier: string | undefined;
+    
+    TargetDBClusterParameterGroupIdentifier: string | undefined;
+    
+    TargetDBClusterParameterGroupDescription: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterParameterGroupMessage) => any;
+}
+
+export interface DBClusterParameterGroup {
+    
+    DBClusterParameterGroupName?: string;
+    
+    DBParameterGroupFamily?: string;
+    
+    Description?: string;
+    
+    DBClusterParameterGroupArn?: string;
+}
+export declare namespace DBClusterParameterGroup {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroup) => any;
+}
+export interface CopyDBClusterParameterGroupResult {
+    
+    DBClusterParameterGroup?: DBClusterParameterGroup;
+}
+export declare namespace CopyDBClusterParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterParameterGroupResult) => any;
+}
+
+export declare class DBParameterGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "DBParameterGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "DBParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DBParameterGroupQuotaExceededFault extends __BaseException {
+    readonly name: "DBParameterGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBParameterGroupQuotaExceededFault, __BaseException>);
+}
+
+export interface CopyDBClusterSnapshotMessage {
+    
+    SourceDBClusterSnapshotIdentifier: string | undefined;
+    
+    TargetDBClusterSnapshotIdentifier: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+    
+    CopyTags?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CopyDBClusterSnapshotMessage) => any;
+}
+
+export interface DBClusterSnapshot {
+    
+    AvailabilityZones?: string[];
+    
+    DBClusterSnapshotIdentifier?: string;
+    
+    DBClusterIdentifier?: string;
+    
+    SnapshotCreateTime?: Date;
+    
+    Engine?: string;
+    
+    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 declare class DBClusterSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterSnapshotAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterSnapshotNotFoundFault extends __BaseException {
+    readonly name: "DBClusterSnapshotNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterSnapshotNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidDBClusterSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterSnapshotStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterSnapshotStateFault, __BaseException>);
+}
+
+export declare class KMSKeyNotAccessibleFault extends __BaseException {
+    readonly name: "KMSKeyNotAccessibleFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<KMSKeyNotAccessibleFault, __BaseException>);
+}
+
+export declare class SnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SnapshotQuotaExceededFault, __BaseException>);
+}
+
+export interface 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;
+    
+    SnapshotTarget?: string;
+}
+export declare namespace DBSnapshot {
+    
+    const filterSensitiveLog: (obj: DBSnapshot) => any;
+}
+export interface CopyDBSnapshotResult {
+    
+    DBSnapshot?: DBSnapshot;
+}
+export declare namespace CopyDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CopyDBSnapshotResult) => any;
+}
+
+export declare class CustomAvailabilityZoneNotFoundFault extends __BaseException {
+    readonly name: "CustomAvailabilityZoneNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomAvailabilityZoneNotFoundFault, __BaseException>);
+}
+
+export declare class DBSnapshotAlreadyExistsFault extends __BaseException {
+    readonly name: "DBSnapshotAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSnapshotAlreadyExistsFault, __BaseException>);
+}
+
+export declare class InvalidDBSnapshotStateFault extends __BaseException {
+    readonly name: "InvalidDBSnapshotStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSnapshotStateFault, __BaseException>);
+}
+
+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 declare class OptionGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "OptionGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OptionGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class OptionGroupNotFoundFault extends __BaseException {
+    readonly name: "OptionGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OptionGroupNotFoundFault, __BaseException>);
+}
+
+export declare class OptionGroupQuotaExceededFault extends __BaseException {
+    readonly name: "OptionGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OptionGroupQuotaExceededFault, __BaseException>);
+}
+
+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 declare class CustomAvailabilityZoneAlreadyExistsFault extends __BaseException {
+    readonly name: "CustomAvailabilityZoneAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomAvailabilityZoneAlreadyExistsFault, __BaseException>);
+}
+
+export declare class CustomAvailabilityZoneQuotaExceededFault extends __BaseException {
+    readonly name: "CustomAvailabilityZoneQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomAvailabilityZoneQuotaExceededFault, __BaseException>);
+}
+export interface CreateCustomDBEngineVersionMessage {
+    
+    Engine: string | undefined;
+    
+    EngineVersion: string | undefined;
+    
+    DatabaseInstallationFilesS3BucketName: string | undefined;
+    
+    DatabaseInstallationFilesS3Prefix?: string;
+    
+    KMSKeyId: string | undefined;
+    
+    Description?: string;
+    
+    Manifest: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateCustomDBEngineVersionMessage {
+    
+    const filterSensitiveLog: (obj: CreateCustomDBEngineVersionMessage) => any;
+}
+
+export declare class CustomDBEngineVersionAlreadyExistsFault extends __BaseException {
+    readonly name: "CustomDBEngineVersionAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionAlreadyExistsFault, __BaseException>);
+}
+
+export declare class CustomDBEngineVersionQuotaExceededFault extends __BaseException {
+    readonly name: "CustomDBEngineVersionQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionQuotaExceededFault, __BaseException>);
+}
+
+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;
+    
+    SupportsBabelfish?: 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;
+    
+    MajorEngineVersion?: string;
+    
+    DatabaseInstallationFilesS3BucketName?: string;
+    
+    DatabaseInstallationFilesS3Prefix?: string;
+    
+    DBEngineVersionArn?: string;
+    
+    KMSKeyId?: string;
+    
+    CreateTime?: Date;
+    
+    TagList?: Tag[];
+    
+    SupportsBabelfish?: boolean;
+}
+export declare namespace DBEngineVersion {
+    
+    const filterSensitiveLog: (obj: DBEngineVersion) => 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;
+    
+    DBClusterInstanceClass?: string;
+    
+    AllocatedStorage?: number;
+    
+    StorageType?: string;
+    
+    Iops?: number;
+    
+    PubliclyAccessible?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+}
+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;
+    
+    DBClusterInstanceClass?: string;
+    
+    StorageType?: string;
+    
+    Iops?: number;
+    
+    PubliclyAccessible?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    PerformanceInsightsEnabled?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+}
+export declare namespace DBCluster {
+    
+    const filterSensitiveLog: (obj: DBCluster) => any;
+}
+export interface CreateDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace CreateDBClusterResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterResult) => any;
+}
+
+export declare class DBClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterParameterGroupNotFoundFault extends __BaseException {
+    readonly name: "DBClusterParameterGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterParameterGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DBClusterQuotaExceededFault extends __BaseException {
+    readonly name: "DBClusterQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBSubnetGroupDoesNotCoverEnoughAZs extends __BaseException {
+    readonly name: "DBSubnetGroupDoesNotCoverEnoughAZs";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupDoesNotCoverEnoughAZs, __BaseException>);
+}
+
+export declare class DBSubnetGroupNotFoundFault extends __BaseException {
+    readonly name: "DBSubnetGroupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotFoundFault, __BaseException>);
+}
+
+export declare class DomainNotFoundFault extends __BaseException {
+    readonly name: "DomainNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DomainNotFoundFault, __BaseException>);
+}
+
+export declare class GlobalClusterNotFoundFault extends __BaseException {
+    readonly name: "GlobalClusterNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterNotFoundFault, __BaseException>);
+}
+
+export declare class InsufficientStorageClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientStorageClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientStorageClusterCapacityFault, __BaseException>);
+}
+
+export declare class InvalidDBSubnetGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBSubnetGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSubnetGroupStateFault, __BaseException>);
+}
+
+export declare class InvalidGlobalClusterStateFault extends __BaseException {
+    readonly name: "InvalidGlobalClusterStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidGlobalClusterStateFault, __BaseException>);
+}
+
+export declare class InvalidSubnet extends __BaseException {
+    readonly name: "InvalidSubnet";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSubnet, __BaseException>);
+}
+
+export declare class InvalidVPCNetworkStateFault extends __BaseException {
+    readonly name: "InvalidVPCNetworkStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidVPCNetworkStateFault, __BaseException>);
+}
+
+export declare class StorageQuotaExceededFault extends __BaseException {
+    readonly name: "StorageQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<StorageQuotaExceededFault, __BaseException>);
+}
+export interface 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 declare class DBClusterEndpointAlreadyExistsFault extends __BaseException {
+    readonly name: "DBClusterEndpointAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterEndpointAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBClusterEndpointQuotaExceededFault extends __BaseException {
+    readonly name: "DBClusterEndpointQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterEndpointQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Description: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterParameterGroupMessage) => any;
+}
+export interface CreateDBClusterParameterGroupResult {
+    
+    DBClusterParameterGroup?: DBClusterParameterGroup;
+}
+export declare namespace CreateDBClusterParameterGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterParameterGroupResult) => any;
+}
+
+export interface CreateDBClusterSnapshotMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+    
+    DBClusterIdentifier: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterSnapshotMessage) => any;
+}
+export interface CreateDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace CreateDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: CreateDBClusterSnapshotResult) => any;
+}
+
+export declare class AuthorizationNotFoundFault extends __BaseException {
+    readonly name: "AuthorizationNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorizationNotFoundFault, __BaseException>);
+}
+export declare class BackupPolicyNotFoundFault extends __BaseException {
+    readonly name: "BackupPolicyNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BackupPolicyNotFoundFault, __BaseException>);
+}
+
+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;
+    
+    CustomIamInstanceProfile?: string;
+    
+    BackupTarget?: string;
+}
+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 declare enum AutomationMode {
+    ALL_PAUSED = "all-paused",
+    FULL = "full"
+}
+
+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;
+    
+    AutomationMode?: AutomationMode | string;
+    
+    ResumeFullAutomationModeTime?: Date;
+}
+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;
+    
+    AutomationMode?: AutomationMode | string;
+    
+    ResumeFullAutomationModeTime?: Date;
+    
+    CustomIamInstanceProfile?: string;
+    
+    BackupTarget?: string;
+}
+export declare namespace DBInstance {
+    
+    const filterSensitiveLog: (obj: DBInstance) => any;
+}
+export interface CreateDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace CreateDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceResult) => any;
+}
+
+export declare class DBInstanceAlreadyExistsFault extends __BaseException {
+    readonly name: "DBInstanceAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceAlreadyExistsFault, __BaseException>);
+}
+
+export declare class InstanceQuotaExceededFault extends __BaseException {
+    readonly name: "InstanceQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InstanceQuotaExceededFault, __BaseException>);
+}
+
+export declare class InsufficientDBInstanceCapacityFault extends __BaseException {
+    readonly name: "InsufficientDBInstanceCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDBInstanceCapacityFault, __BaseException>);
+}
+
+export declare class ProvisionedIopsNotAvailableInAZFault extends __BaseException {
+    readonly name: "ProvisionedIopsNotAvailableInAZFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ProvisionedIopsNotAvailableInAZFault, __BaseException>);
+}
+
+export declare class StorageTypeNotSupportedFault extends __BaseException {
+    readonly name: "StorageTypeNotSupportedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<StorageTypeNotSupportedFault, __BaseException>);
+}
+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;
+    
+    CustomIamInstanceProfile?: string;
+}
+export declare namespace CreateDBInstanceReadReplicaMessage {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceReadReplicaMessage) => any;
+}
+export interface CreateDBInstanceReadReplicaResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace CreateDBInstanceReadReplicaResult {
+    
+    const filterSensitiveLog: (obj: CreateDBInstanceReadReplicaResult) => any;
+}
+
+export declare class DBSubnetGroupNotAllowedFault extends __BaseException {
+    readonly name: "DBSubnetGroupNotAllowedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupNotAllowedFault, __BaseException>);
+}
+
+export declare class InvalidDBSubnetGroupFault extends __BaseException {
+    readonly name: "InvalidDBSubnetGroupFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSubnetGroupFault, __BaseException>);
+}
+
+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 declare class DBProxyAlreadyExistsFault extends __BaseException {
+    readonly name: "DBProxyAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBProxyQuotaExceededFault extends __BaseException {
+    readonly name: "DBProxyQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyQuotaExceededFault, __BaseException>);
+}
+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 declare class DBProxyEndpointAlreadyExistsFault extends __BaseException {
+    readonly name: "DBProxyEndpointAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyEndpointAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBProxyEndpointQuotaExceededFault extends __BaseException {
+    readonly name: "DBProxyEndpointQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyEndpointQuotaExceededFault, __BaseException>);
+}
+
+export declare class InvalidDBProxyStateFault extends __BaseException {
+    readonly name: "InvalidDBProxyStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBProxyStateFault, __BaseException>);
+}
+
+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 declare class DBSecurityGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "DBSecurityGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSecurityGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBSecurityGroupNotSupportedFault extends __BaseException {
+    readonly name: "DBSecurityGroupNotSupportedFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSecurityGroupNotSupportedFault, __BaseException>);
+}
+
+export declare class DBSecurityGroupQuotaExceededFault extends __BaseException {
+    readonly name: "DBSecurityGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSecurityGroupQuotaExceededFault, __BaseException>);
+}
+
+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 declare class DBSubnetGroupAlreadyExistsFault extends __BaseException {
+    readonly name: "DBSubnetGroupAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupAlreadyExistsFault, __BaseException>);
+}
+
+export declare class DBSubnetGroupQuotaExceededFault extends __BaseException {
+    readonly name: "DBSubnetGroupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetGroupQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBSubnetQuotaExceededFault extends __BaseException {
+    readonly name: "DBSubnetQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBSubnetQuotaExceededFault, __BaseException>);
+}
+
+export interface CreateEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn: string | undefined;
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+    
+    SourceIds?: string[];
+    
+    Enabled?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionMessage) => any;
+}
+export interface CreateEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace CreateEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: CreateEventSubscriptionResult) => any;
+}
+
+export declare class EventSubscriptionQuotaExceededFault extends __BaseException {
+    readonly name: "EventSubscriptionQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EventSubscriptionQuotaExceededFault, __BaseException>);
+}
+
+export declare class SNSInvalidTopicFault extends __BaseException {
+    readonly name: "SNSInvalidTopicFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSInvalidTopicFault, __BaseException>);
+}
+
+export declare class SNSNoAuthorizationFault extends __BaseException {
+    readonly name: "SNSNoAuthorizationFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSNoAuthorizationFault, __BaseException>);
+}
+
+export declare class SNSTopicArnNotFoundFault extends __BaseException {
+    readonly name: "SNSTopicArnNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SNSTopicArnNotFoundFault, __BaseException>);
+}
+
+export declare class SubscriptionAlreadyExistFault extends __BaseException {
+    readonly name: "SubscriptionAlreadyExistFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionAlreadyExistFault, __BaseException>);
+}
+
+export declare class SubscriptionCategoryNotFoundFault extends __BaseException {
+    readonly name: "SubscriptionCategoryNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubscriptionCategoryNotFoundFault, __BaseException>);
+}
+export interface CreateGlobalClusterMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    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 declare class GlobalClusterAlreadyExistsFault extends __BaseException {
+    readonly name: "GlobalClusterAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterAlreadyExistsFault, __BaseException>);
+}
+
+export declare class GlobalClusterQuotaExceededFault extends __BaseException {
+    readonly name: "GlobalClusterQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<GlobalClusterQuotaExceededFault, __BaseException>);
+}
+
+export interface 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 declare class CustomDBEngineVersionNotFoundFault extends __BaseException {
+    readonly name: "CustomDBEngineVersionNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CustomDBEngineVersionNotFoundFault, __BaseException>);
+}
+export interface DeleteCustomDBEngineVersionMessage {
+    
+    Engine: string | undefined;
+    
+    EngineVersion: string | undefined;
+}
+export declare namespace DeleteCustomDBEngineVersionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteCustomDBEngineVersionMessage) => any;
+}
+
+export declare class InvalidCustomDBEngineVersionStateFault extends __BaseException {
+    readonly name: "InvalidCustomDBEngineVersionStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidCustomDBEngineVersionStateFault, __BaseException>);
+}
+
+export interface DeleteDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    SkipFinalSnapshot?: boolean;
+    
+    FinalDBSnapshotIdentifier?: string;
+}
+export declare namespace DeleteDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterMessage) => any;
+}
+export interface DeleteDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace DeleteDBClusterResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterResult) => any;
+}
+
+export declare class DBClusterEndpointNotFoundFault extends __BaseException {
+    readonly name: "DBClusterEndpointNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterEndpointNotFoundFault, __BaseException>);
+}
+export interface DeleteDBClusterEndpointMessage {
+    
+    DBClusterEndpointIdentifier: string | undefined;
+}
+export declare namespace DeleteDBClusterEndpointMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterEndpointMessage) => any;
+}
+
+export declare class InvalidDBClusterEndpointStateFault extends __BaseException {
+    readonly name: "InvalidDBClusterEndpointStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterEndpointStateFault, __BaseException>);
+}
+
+export interface DeleteDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+}
+export declare namespace DeleteDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterParameterGroupMessage) => any;
+}
+
+export declare class InvalidDBParameterGroupStateFault extends __BaseException {
+    readonly name: "InvalidDBParameterGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBParameterGroupStateFault, __BaseException>);
+}
+
+export interface DeleteDBClusterSnapshotMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+}
+export declare namespace DeleteDBClusterSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterSnapshotMessage) => any;
+}
+export interface DeleteDBClusterSnapshotResult {
+    
+    DBClusterSnapshot?: DBClusterSnapshot;
+}
+export declare namespace DeleteDBClusterSnapshotResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBClusterSnapshotResult) => any;
+}
+
+export declare class DBInstanceAutomatedBackupQuotaExceededFault extends __BaseException {
+    readonly name: "DBInstanceAutomatedBackupQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceAutomatedBackupQuotaExceededFault, __BaseException>);
+}
+
+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 declare class DBInstanceAutomatedBackupNotFoundFault extends __BaseException {
+    readonly name: "DBInstanceAutomatedBackupNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceAutomatedBackupNotFoundFault, __BaseException>);
+}
+
+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[];
+    
+    BackupTarget?: string;
+}
+export declare namespace DBInstanceAutomatedBackup {
+    
+    const filterSensitiveLog: (obj: DBInstanceAutomatedBackup) => any;
+}
+export interface DeleteDBInstanceAutomatedBackupResult {
+    
+    DBInstanceAutomatedBackup?: DBInstanceAutomatedBackup;
+}
+export declare namespace DeleteDBInstanceAutomatedBackupResult {
+    
+    const filterSensitiveLog: (obj: DeleteDBInstanceAutomatedBackupResult) => any;
+}
+
+export declare class InvalidDBInstanceAutomatedBackupStateFault extends __BaseException {
+    readonly name: "InvalidDBInstanceAutomatedBackupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBInstanceAutomatedBackupStateFault, __BaseException>);
+}
+
+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 declare class DBProxyEndpointNotFoundFault extends __BaseException {
+    readonly name: "DBProxyEndpointNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyEndpointNotFoundFault, __BaseException>);
+}
+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 declare class InvalidDBProxyEndpointStateFault extends __BaseException {
+    readonly name: "InvalidDBProxyEndpointStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBProxyEndpointStateFault, __BaseException>);
+}
+
+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 declare class InvalidDBSubnetStateFault extends __BaseException {
+    readonly name: "InvalidDBSubnetStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBSubnetStateFault, __BaseException>);
+}
+
+export interface DeleteEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+}
+export declare namespace DeleteEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionMessage) => any;
+}
+export interface DeleteEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace DeleteEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: DeleteEventSubscriptionResult) => any;
+}
+
+export declare class InvalidEventSubscriptionStateFault extends __BaseException {
+    readonly name: "InvalidEventSubscriptionStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidEventSubscriptionStateFault, __BaseException>);
+}
+export interface DeleteGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+}
+export declare namespace DeleteGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalClusterMessage) => any;
+}
+export interface DeleteGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace DeleteGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalClusterResult) => any;
+}
+export interface 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 declare class InstallationMediaNotFoundFault extends __BaseException {
+    readonly name: "InstallationMediaNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InstallationMediaNotFoundFault, __BaseException>);
+}
+
+export interface DeleteOptionGroupMessage {
+    
+    OptionGroupName: string | undefined;
+}
+export declare namespace DeleteOptionGroupMessage {
+    
+    const filterSensitiveLog: (obj: DeleteOptionGroupMessage) => any;
+}
+
+export declare class InvalidOptionGroupStateFault extends __BaseException {
+    readonly name: "InvalidOptionGroupStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidOptionGroupStateFault, __BaseException>);
+}
+
+export declare class DBProxyTargetNotFoundFault extends __BaseException {
+    readonly name: "DBProxyTargetNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyTargetNotFoundFault, __BaseException>);
+}
+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 declare class CertificateNotFoundFault extends __BaseException {
+    readonly name: "CertificateNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CertificateNotFoundFault, __BaseException>);
+}
+
+export interface Filter {
+    
+    Name: string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+
+export interface DescribeCertificatesMessage {
+    
+    CertificateIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeCertificatesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeCertificatesMessage) => any;
+}
+export interface 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 declare class DBClusterBacktrackNotFoundFault extends __BaseException {
+    readonly name: "DBClusterBacktrackNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterBacktrackNotFoundFault, __BaseException>);
+}
+
+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 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;
+}