@aws-sdk/client-rds 3.50.0 → 3.53.0

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

@@ -0,0 +1,2737 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ActivityStreamMode, ActivityStreamStatus, AutomationMode, AvailabilityZone, Certificate, DBCluster, DBClusterSnapshotAttributesResult, DBInstance, DBInstanceAutomatedBackup, DBProxy, DBProxyEndpoint, DBProxyTargetGroup, DBSecurityGroup, DBSnapshot, DBSubnetGroup, EventSubscription, ExportTask, Filter, GlobalCluster, InstallationMedia, OptionGroup, OptionSetting, Parameter, ProcessorFeature, ReplicaMode, ResourcePendingMaintenanceActions, ScalingConfiguration, Tag, UserAuthConfig } from "./models_0";
+import { RDSServiceException as __BaseException } from "./RDSServiceException";
+export declare enum TargetRole {
+    READ_ONLY = "READ_ONLY",
+    READ_WRITE = "READ_WRITE",
+    UNKNOWN = "UNKNOWN"
+}
+export declare enum TargetHealthReason {
+    AUTH_FAILURE = "AUTH_FAILURE",
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    INVALID_REPLICATION_STATE = "INVALID_REPLICATION_STATE",
+    PENDING_PROXY_CAPACITY = "PENDING_PROXY_CAPACITY",
+    UNREACHABLE = "UNREACHABLE"
+}
+export declare enum TargetState {
+    available = "AVAILABLE",
+    registering = "REGISTERING",
+    unavailable = "UNAVAILABLE"
+}
+
+export interface TargetHealth {
+    
+    State?: TargetState | string;
+    
+    Reason?: TargetHealthReason | string;
+    
+    Description?: string;
+}
+export declare namespace TargetHealth {
+    
+    const filterSensitiveLog: (obj: TargetHealth) => any;
+}
+export declare enum TargetType {
+    RDS_INSTANCE = "RDS_INSTANCE",
+    RDS_SERVERLESS_ENDPOINT = "RDS_SERVERLESS_ENDPOINT",
+    TRACKED_CLUSTER = "TRACKED_CLUSTER"
+}
+
+export interface DBProxyTarget {
+    
+    TargetArn?: string;
+    
+    Endpoint?: string;
+    
+    TrackedClusterId?: string;
+    
+    RdsResourceId?: string;
+    
+    Port?: number;
+    
+    Type?: TargetType | string;
+    
+    Role?: TargetRole | string;
+    
+    TargetHealth?: TargetHealth;
+}
+export declare namespace DBProxyTarget {
+    
+    const filterSensitiveLog: (obj: DBProxyTarget) => any;
+}
+export interface DescribeDBProxyTargetsResponse {
+    
+    Targets?: DBProxyTarget[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBProxyTargetsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDBProxyTargetsResponse) => any;
+}
+
+export interface DBSecurityGroupMessage {
+    
+    Marker?: string;
+    
+    DBSecurityGroups?: DBSecurityGroup[];
+}
+export declare namespace DBSecurityGroupMessage {
+    
+    const filterSensitiveLog: (obj: DBSecurityGroupMessage) => any;
+}
+
+export interface DescribeDBSecurityGroupsMessage {
+    
+    DBSecurityGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBSecurityGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBSecurityGroupsMessage) => any;
+}
+
+export interface DescribeDBSnapshotAttributesMessage {
+    
+    DBSnapshotIdentifier: string | undefined;
+}
+export declare namespace DescribeDBSnapshotAttributesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBSnapshotAttributesMessage) => any;
+}
+
+export interface DBSnapshotAttribute {
+    
+    AttributeName?: string;
+    
+    AttributeValues?: string[];
+}
+export declare namespace DBSnapshotAttribute {
+    
+    const filterSensitiveLog: (obj: DBSnapshotAttribute) => any;
+}
+
+export interface DBSnapshotAttributesResult {
+    
+    DBSnapshotIdentifier?: string;
+    
+    DBSnapshotAttributes?: DBSnapshotAttribute[];
+}
+export declare namespace DBSnapshotAttributesResult {
+    
+    const filterSensitiveLog: (obj: DBSnapshotAttributesResult) => any;
+}
+export interface DescribeDBSnapshotAttributesResult {
+    
+    DBSnapshotAttributesResult?: DBSnapshotAttributesResult;
+}
+export declare namespace DescribeDBSnapshotAttributesResult {
+    
+    const filterSensitiveLog: (obj: DescribeDBSnapshotAttributesResult) => any;
+}
+
+export interface DBSnapshotMessage {
+    
+    Marker?: string;
+    
+    DBSnapshots?: DBSnapshot[];
+}
+export declare namespace DBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: DBSnapshotMessage) => any;
+}
+
+export interface DescribeDBSnapshotsMessage {
+    
+    DBInstanceIdentifier?: string;
+    
+    DBSnapshotIdentifier?: string;
+    
+    SnapshotType?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    IncludeShared?: boolean;
+    
+    IncludePublic?: boolean;
+    
+    DbiResourceId?: string;
+}
+export declare namespace DescribeDBSnapshotsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBSnapshotsMessage) => any;
+}
+
+export interface DBSubnetGroupMessage {
+    
+    Marker?: string;
+    
+    DBSubnetGroups?: DBSubnetGroup[];
+}
+export declare namespace DBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: DBSubnetGroupMessage) => any;
+}
+
+export interface DescribeDBSubnetGroupsMessage {
+    
+    DBSubnetGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeDBSubnetGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeDBSubnetGroupsMessage) => any;
+}
+
+export interface DescribeEngineDefaultClusterParametersMessage {
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEngineDefaultClusterParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultClusterParametersMessage) => any;
+}
+
+export interface EngineDefaults {
+    
+    DBParameterGroupFamily?: string;
+    
+    Marker?: string;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace EngineDefaults {
+    
+    const filterSensitiveLog: (obj: EngineDefaults) => any;
+}
+export interface DescribeEngineDefaultClusterParametersResult {
+    
+    EngineDefaults?: EngineDefaults;
+}
+export declare namespace DescribeEngineDefaultClusterParametersResult {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultClusterParametersResult) => any;
+}
+
+export interface DescribeEngineDefaultParametersMessage {
+    
+    DBParameterGroupFamily: string | undefined;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEngineDefaultParametersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultParametersMessage) => any;
+}
+export interface DescribeEngineDefaultParametersResult {
+    
+    EngineDefaults?: EngineDefaults;
+}
+export declare namespace DescribeEngineDefaultParametersResult {
+    
+    const filterSensitiveLog: (obj: DescribeEngineDefaultParametersResult) => any;
+}
+
+export interface DescribeEventCategoriesMessage {
+    
+    SourceType?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace DescribeEventCategoriesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventCategoriesMessage) => any;
+}
+
+export interface EventCategoriesMap {
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+}
+export declare namespace EventCategoriesMap {
+    
+    const filterSensitiveLog: (obj: EventCategoriesMap) => any;
+}
+
+export interface EventCategoriesMessage {
+    
+    EventCategoriesMapList?: EventCategoriesMap[];
+}
+export declare namespace EventCategoriesMessage {
+    
+    const filterSensitiveLog: (obj: EventCategoriesMessage) => any;
+}
+export declare type SourceType = "custom-engine-version" | "db-cluster" | "db-cluster-snapshot" | "db-instance" | "db-parameter-group" | "db-proxy" | "db-security-group" | "db-snapshot";
+
+export interface DescribeEventsMessage {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Duration?: number;
+    
+    EventCategories?: string[];
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventsMessage) => any;
+}
+
+export interface Event {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    Message?: string;
+    
+    EventCategories?: string[];
+    
+    Date?: Date;
+    
+    SourceArn?: string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface EventsMessage {
+    
+    Marker?: string;
+    
+    Events?: Event[];
+}
+export declare namespace EventsMessage {
+    
+    const filterSensitiveLog: (obj: EventsMessage) => any;
+}
+
+export interface DescribeEventSubscriptionsMessage {
+    
+    SubscriptionName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventSubscriptionsMessage) => any;
+}
+
+export interface EventSubscriptionsMessage {
+    
+    Marker?: string;
+    
+    EventSubscriptionsList?: EventSubscription[];
+}
+export declare namespace EventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EventSubscriptionsMessage) => any;
+}
+export interface DescribeExportTasksMessage {
+    
+    ExportTaskIdentifier?: string;
+    
+    SourceArn?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribeExportTasksMessage {
+    
+    const filterSensitiveLog: (obj: DescribeExportTasksMessage) => any;
+}
+export interface ExportTasksMessage {
+    
+    Marker?: string;
+    
+    ExportTasks?: ExportTask[];
+}
+export declare namespace ExportTasksMessage {
+    
+    const filterSensitiveLog: (obj: ExportTasksMessage) => any;
+}
+export interface DescribeGlobalClustersMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeGlobalClustersMessage {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalClustersMessage) => any;
+}
+export interface GlobalClustersMessage {
+    
+    Marker?: string;
+    
+    GlobalClusters?: GlobalCluster[];
+}
+export declare namespace GlobalClustersMessage {
+    
+    const filterSensitiveLog: (obj: GlobalClustersMessage) => any;
+}
+export interface DescribeInstallationMediaMessage {
+    
+    InstallationMediaId?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeInstallationMediaMessage {
+    
+    const filterSensitiveLog: (obj: DescribeInstallationMediaMessage) => any;
+}
+export interface InstallationMediaMessage {
+    
+    Marker?: string;
+    
+    InstallationMedia?: InstallationMedia[];
+}
+export declare namespace InstallationMediaMessage {
+    
+    const filterSensitiveLog: (obj: InstallationMediaMessage) => any;
+}
+
+export interface DescribeOptionGroupOptionsMessage {
+    
+    EngineName: string | undefined;
+    
+    MajorEngineVersion?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeOptionGroupOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeOptionGroupOptionsMessage) => any;
+}
+
+export interface MinimumEngineVersionPerAllowedValue {
+    
+    AllowedValue?: string;
+    
+    MinimumEngineVersion?: string;
+}
+export declare namespace MinimumEngineVersionPerAllowedValue {
+    
+    const filterSensitiveLog: (obj: MinimumEngineVersionPerAllowedValue) => any;
+}
+
+export interface OptionGroupOptionSetting {
+    
+    SettingName?: string;
+    
+    SettingDescription?: string;
+    
+    DefaultValue?: string;
+    
+    ApplyType?: string;
+    
+    AllowedValues?: string;
+    
+    IsModifiable?: boolean;
+    
+    IsRequired?: boolean;
+    
+    MinimumEngineVersionPerAllowedValue?: MinimumEngineVersionPerAllowedValue[];
+}
+export declare namespace OptionGroupOptionSetting {
+    
+    const filterSensitiveLog: (obj: OptionGroupOptionSetting) => any;
+}
+
+export interface OptionVersion {
+    
+    Version?: string;
+    
+    IsDefault?: boolean;
+}
+export declare namespace OptionVersion {
+    
+    const filterSensitiveLog: (obj: OptionVersion) => any;
+}
+
+export interface OptionGroupOption {
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    EngineName?: string;
+    
+    MajorEngineVersion?: string;
+    
+    MinimumRequiredMinorEngineVersion?: string;
+    
+    PortRequired?: boolean;
+    
+    DefaultPort?: number;
+    
+    OptionsDependedOn?: string[];
+    
+    OptionsConflictsWith?: string[];
+    
+    Persistent?: boolean;
+    
+    Permanent?: boolean;
+    
+    RequiresAutoMinorEngineVersionUpgrade?: boolean;
+    
+    VpcOnly?: boolean;
+    
+    SupportsOptionVersionDowngrade?: boolean;
+    
+    OptionGroupOptionSettings?: OptionGroupOptionSetting[];
+    
+    OptionGroupOptionVersions?: OptionVersion[];
+}
+export declare namespace OptionGroupOption {
+    
+    const filterSensitiveLog: (obj: OptionGroupOption) => any;
+}
+
+export interface OptionGroupOptionsMessage {
+    
+    OptionGroupOptions?: OptionGroupOption[];
+    
+    Marker?: string;
+}
+export declare namespace OptionGroupOptionsMessage {
+    
+    const filterSensitiveLog: (obj: OptionGroupOptionsMessage) => any;
+}
+
+export interface DescribeOptionGroupsMessage {
+    
+    OptionGroupName?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+    
+    EngineName?: string;
+    
+    MajorEngineVersion?: string;
+}
+export declare namespace DescribeOptionGroupsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeOptionGroupsMessage) => any;
+}
+
+export interface OptionGroups {
+    
+    OptionGroupsList?: OptionGroup[];
+    
+    Marker?: string;
+}
+export declare namespace OptionGroups {
+    
+    const filterSensitiveLog: (obj: OptionGroups) => any;
+}
+
+export interface DescribeOrderableDBInstanceOptionsMessage {
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    DBInstanceClass?: string;
+    
+    LicenseModel?: string;
+    
+    AvailabilityZoneGroup?: string;
+    
+    Vpc?: boolean;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeOrderableDBInstanceOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeOrderableDBInstanceOptionsMessage) => any;
+}
+
+export interface AvailableProcessorFeature {
+    
+    Name?: string;
+    
+    DefaultValue?: string;
+    
+    AllowedValues?: string;
+}
+export declare namespace AvailableProcessorFeature {
+    
+    const filterSensitiveLog: (obj: AvailableProcessorFeature) => any;
+}
+
+export interface OrderableDBInstanceOption {
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    DBInstanceClass?: string;
+    
+    LicenseModel?: string;
+    
+    AvailabilityZoneGroup?: string;
+    
+    AvailabilityZones?: AvailabilityZone[];
+    
+    MultiAZCapable?: boolean;
+    
+    ReadReplicaCapable?: boolean;
+    
+    Vpc?: boolean;
+    
+    SupportsStorageEncryption?: boolean;
+    
+    StorageType?: string;
+    
+    SupportsIops?: boolean;
+    
+    SupportsEnhancedMonitoring?: boolean;
+    
+    SupportsIAMDatabaseAuthentication?: boolean;
+    
+    SupportsPerformanceInsights?: boolean;
+    
+    MinStorageSize?: number;
+    
+    MaxStorageSize?: number;
+    
+    MinIopsPerDbInstance?: number;
+    
+    MaxIopsPerDbInstance?: number;
+    
+    MinIopsPerGib?: number;
+    
+    MaxIopsPerGib?: number;
+    
+    AvailableProcessorFeatures?: AvailableProcessorFeature[];
+    
+    SupportedEngineModes?: string[];
+    
+    SupportsStorageAutoscaling?: boolean;
+    
+    SupportsKerberosAuthentication?: boolean;
+    
+    OutpostCapable?: boolean;
+    
+    SupportedActivityStreamModes?: string[];
+    
+    SupportsGlobalDatabases?: boolean;
+    
+    SupportsClusters?: boolean;
+}
+export declare namespace OrderableDBInstanceOption {
+    
+    const filterSensitiveLog: (obj: OrderableDBInstanceOption) => any;
+}
+
+export interface OrderableDBInstanceOptionsMessage {
+    
+    OrderableDBInstanceOptions?: OrderableDBInstanceOption[];
+    
+    Marker?: string;
+}
+export declare namespace OrderableDBInstanceOptionsMessage {
+    
+    const filterSensitiveLog: (obj: OrderableDBInstanceOptionsMessage) => any;
+}
+
+export interface DescribePendingMaintenanceActionsMessage {
+    
+    ResourceIdentifier?: string;
+    
+    Filters?: Filter[];
+    
+    Marker?: string;
+    
+    MaxRecords?: number;
+}
+export declare namespace DescribePendingMaintenanceActionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribePendingMaintenanceActionsMessage) => any;
+}
+
+export interface PendingMaintenanceActionsMessage {
+    
+    PendingMaintenanceActions?: ResourcePendingMaintenanceActions[];
+    
+    Marker?: string;
+}
+export declare namespace PendingMaintenanceActionsMessage {
+    
+    const filterSensitiveLog: (obj: PendingMaintenanceActionsMessage) => any;
+}
+
+export interface DescribeReservedDBInstancesMessage {
+    
+    ReservedDBInstanceId?: string;
+    
+    ReservedDBInstancesOfferingId?: string;
+    
+    DBInstanceClass?: string;
+    
+    Duration?: string;
+    
+    ProductDescription?: string;
+    
+    OfferingType?: string;
+    
+    MultiAZ?: boolean;
+    
+    LeaseId?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeReservedDBInstancesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeReservedDBInstancesMessage) => any;
+}
+
+export interface RecurringCharge {
+    
+    RecurringChargeAmount?: number;
+    
+    RecurringChargeFrequency?: string;
+}
+export declare namespace RecurringCharge {
+    
+    const filterSensitiveLog: (obj: RecurringCharge) => any;
+}
+
+export interface ReservedDBInstance {
+    
+    ReservedDBInstanceId?: string;
+    
+    ReservedDBInstancesOfferingId?: string;
+    
+    DBInstanceClass?: string;
+    
+    StartTime?: Date;
+    
+    Duration?: number;
+    
+    FixedPrice?: number;
+    
+    UsagePrice?: number;
+    
+    CurrencyCode?: string;
+    
+    DBInstanceCount?: number;
+    
+    ProductDescription?: string;
+    
+    OfferingType?: string;
+    
+    MultiAZ?: boolean;
+    
+    State?: string;
+    
+    RecurringCharges?: RecurringCharge[];
+    
+    ReservedDBInstanceArn?: string;
+    
+    LeaseId?: string;
+}
+export declare namespace ReservedDBInstance {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstance) => any;
+}
+
+export interface ReservedDBInstanceMessage {
+    
+    Marker?: string;
+    
+    ReservedDBInstances?: ReservedDBInstance[];
+}
+export declare namespace ReservedDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstanceMessage) => any;
+}
+
+export declare class ReservedDBInstanceNotFoundFault extends __BaseException {
+    readonly name: "ReservedDBInstanceNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedDBInstanceNotFoundFault, __BaseException>);
+}
+
+export interface DescribeReservedDBInstancesOfferingsMessage {
+    
+    ReservedDBInstancesOfferingId?: string;
+    
+    DBInstanceClass?: string;
+    
+    Duration?: string;
+    
+    ProductDescription?: string;
+    
+    OfferingType?: string;
+    
+    MultiAZ?: boolean;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeReservedDBInstancesOfferingsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeReservedDBInstancesOfferingsMessage) => any;
+}
+
+export interface ReservedDBInstancesOffering {
+    
+    ReservedDBInstancesOfferingId?: string;
+    
+    DBInstanceClass?: string;
+    
+    Duration?: number;
+    
+    FixedPrice?: number;
+    
+    UsagePrice?: number;
+    
+    CurrencyCode?: string;
+    
+    ProductDescription?: string;
+    
+    OfferingType?: string;
+    
+    MultiAZ?: boolean;
+    
+    RecurringCharges?: RecurringCharge[];
+}
+export declare namespace ReservedDBInstancesOffering {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstancesOffering) => any;
+}
+
+export interface ReservedDBInstancesOfferingMessage {
+    
+    Marker?: string;
+    
+    ReservedDBInstancesOfferings?: ReservedDBInstancesOffering[];
+}
+export declare namespace ReservedDBInstancesOfferingMessage {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstancesOfferingMessage) => any;
+}
+
+export declare class ReservedDBInstancesOfferingNotFoundFault extends __BaseException {
+    readonly name: "ReservedDBInstancesOfferingNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedDBInstancesOfferingNotFoundFault, __BaseException>);
+}
+
+export interface DescribeSourceRegionsMessage {
+    
+    RegionName?: string;
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+    
+    Filters?: Filter[];
+}
+export declare namespace DescribeSourceRegionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeSourceRegionsMessage) => any;
+}
+
+export interface SourceRegion {
+    
+    RegionName?: string;
+    
+    Endpoint?: string;
+    
+    Status?: string;
+    
+    SupportsDBInstanceAutomatedBackupsReplication?: boolean;
+}
+export declare namespace SourceRegion {
+    
+    const filterSensitiveLog: (obj: SourceRegion) => any;
+}
+
+export interface SourceRegionMessage {
+    
+    Marker?: string;
+    
+    SourceRegions?: SourceRegion[];
+}
+export declare namespace SourceRegionMessage {
+    
+    const filterSensitiveLog: (obj: SourceRegionMessage) => any;
+}
+
+export interface DescribeValidDBInstanceModificationsMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+}
+export declare namespace DescribeValidDBInstanceModificationsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeValidDBInstanceModificationsMessage) => any;
+}
+
+export interface DoubleRange {
+    
+    From?: number;
+    
+    To?: number;
+}
+export declare namespace DoubleRange {
+    
+    const filterSensitiveLog: (obj: DoubleRange) => any;
+}
+
+export interface Range {
+    
+    From?: number;
+    
+    To?: number;
+    
+    Step?: number;
+}
+export declare namespace Range {
+    
+    const filterSensitiveLog: (obj: Range) => any;
+}
+
+export interface ValidStorageOptions {
+    
+    StorageType?: string;
+    
+    StorageSize?: Range[];
+    
+    ProvisionedIops?: Range[];
+    
+    IopsToStorageRatio?: DoubleRange[];
+    
+    SupportsStorageAutoscaling?: boolean;
+}
+export declare namespace ValidStorageOptions {
+    
+    const filterSensitiveLog: (obj: ValidStorageOptions) => any;
+}
+
+export interface ValidDBInstanceModificationsMessage {
+    
+    Storage?: ValidStorageOptions[];
+    
+    ValidProcessorFeatures?: AvailableProcessorFeature[];
+}
+export declare namespace ValidDBInstanceModificationsMessage {
+    
+    const filterSensitiveLog: (obj: ValidDBInstanceModificationsMessage) => any;
+}
+export interface DescribeValidDBInstanceModificationsResult {
+    
+    ValidDBInstanceModificationsMessage?: ValidDBInstanceModificationsMessage;
+}
+export declare namespace DescribeValidDBInstanceModificationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeValidDBInstanceModificationsResult) => any;
+}
+
+export declare class DBLogFileNotFoundFault extends __BaseException {
+    readonly name: "DBLogFileNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBLogFileNotFoundFault, __BaseException>);
+}
+
+export interface DownloadDBLogFilePortionDetails {
+    
+    LogFileData?: string;
+    
+    Marker?: string;
+    
+    AdditionalDataPending?: boolean;
+}
+export declare namespace DownloadDBLogFilePortionDetails {
+    
+    const filterSensitiveLog: (obj: DownloadDBLogFilePortionDetails) => any;
+}
+
+export interface DownloadDBLogFilePortionMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    LogFileName: string | undefined;
+    
+    Marker?: string;
+    
+    NumberOfLines?: number;
+}
+export declare namespace DownloadDBLogFilePortionMessage {
+    
+    const filterSensitiveLog: (obj: DownloadDBLogFilePortionMessage) => any;
+}
+
+export interface FailoverDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    TargetDBInstanceIdentifier?: string;
+}
+export declare namespace FailoverDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: FailoverDBClusterMessage) => any;
+}
+export interface FailoverDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace FailoverDBClusterResult {
+    
+    const filterSensitiveLog: (obj: FailoverDBClusterResult) => any;
+}
+export interface FailoverGlobalClusterMessage {
+    
+    GlobalClusterIdentifier: string | undefined;
+    
+    TargetDbClusterIdentifier: string | undefined;
+}
+export declare namespace FailoverGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: FailoverGlobalClusterMessage) => any;
+}
+export interface FailoverGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace FailoverGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: FailoverGlobalClusterResult) => any;
+}
+export interface ImportInstallationMediaMessage {
+    
+    CustomAvailabilityZoneId: string | undefined;
+    
+    Engine: string | undefined;
+    
+    EngineVersion: string | undefined;
+    
+    EngineInstallationMediaPath: string | undefined;
+    
+    OSInstallationMediaPath: string | undefined;
+}
+export declare namespace ImportInstallationMediaMessage {
+    
+    const filterSensitiveLog: (obj: ImportInstallationMediaMessage) => any;
+}
+
+export declare class InstallationMediaAlreadyExistsFault extends __BaseException {
+    readonly name: "InstallationMediaAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InstallationMediaAlreadyExistsFault, __BaseException>);
+}
+
+export interface ListTagsForResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListTagsForResourceMessage {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceMessage) => any;
+}
+
+export interface TagListMessage {
+    
+    TagList?: Tag[];
+}
+export declare namespace TagListMessage {
+    
+    const filterSensitiveLog: (obj: TagListMessage) => any;
+}
+export interface ModifyCertificatesMessage {
+    
+    CertificateIdentifier?: string;
+    
+    RemoveCustomerOverride?: boolean;
+}
+export declare namespace ModifyCertificatesMessage {
+    
+    const filterSensitiveLog: (obj: ModifyCertificatesMessage) => any;
+}
+export interface ModifyCertificatesResult {
+    
+    Certificate?: Certificate;
+}
+export declare namespace ModifyCertificatesResult {
+    
+    const filterSensitiveLog: (obj: ModifyCertificatesResult) => any;
+}
+export interface DBClusterCapacityInfo {
+    
+    DBClusterIdentifier?: string;
+    
+    PendingCapacity?: number;
+    
+    CurrentCapacity?: number;
+    
+    SecondsBeforeTimeout?: number;
+    
+    TimeoutAction?: string;
+}
+export declare namespace DBClusterCapacityInfo {
+    
+    const filterSensitiveLog: (obj: DBClusterCapacityInfo) => any;
+}
+
+export declare class InvalidDBClusterCapacityFault extends __BaseException {
+    readonly name: "InvalidDBClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDBClusterCapacityFault, __BaseException>);
+}
+export interface ModifyCurrentDBClusterCapacityMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    Capacity?: number;
+    
+    SecondsBeforeTimeout?: number;
+    
+    TimeoutAction?: string;
+}
+export declare namespace ModifyCurrentDBClusterCapacityMessage {
+    
+    const filterSensitiveLog: (obj: ModifyCurrentDBClusterCapacityMessage) => any;
+}
+export declare enum CustomEngineVersionStatus {
+    available = "available",
+    inactive = "inactive",
+    inactive_except_restore = "inactive-except-restore"
+}
+export interface ModifyCustomDBEngineVersionMessage {
+    
+    Engine: string | undefined;
+    
+    EngineVersion: string | undefined;
+    
+    Description?: string;
+    
+    Status?: CustomEngineVersionStatus | string;
+}
+export declare namespace ModifyCustomDBEngineVersionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyCustomDBEngineVersionMessage) => any;
+}
+
+export interface CloudwatchLogsExportConfiguration {
+    
+    EnableLogTypes?: string[];
+    
+    DisableLogTypes?: string[];
+}
+export declare namespace CloudwatchLogsExportConfiguration {
+    
+    const filterSensitiveLog: (obj: CloudwatchLogsExportConfiguration) => any;
+}
+
+export interface ModifyDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    NewDBClusterIdentifier?: string;
+    
+    ApplyImmediately?: boolean;
+    
+    BackupRetentionPeriod?: number;
+    
+    DBClusterParameterGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Port?: number;
+    
+    MasterUserPassword?: string;
+    
+    OptionGroupName?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    BacktrackWindow?: number;
+    
+    CloudwatchLogsExportConfiguration?: CloudwatchLogsExportConfiguration;
+    
+    EngineVersion?: string;
+    
+    AllowMajorVersionUpgrade?: boolean;
+    
+    DBInstanceParameterGroupName?: string;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    ScalingConfiguration?: ScalingConfiguration;
+    
+    DeletionProtection?: boolean;
+    
+    EnableHttpEndpoint?: boolean;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    EnableGlobalWriteForwarding?: boolean;
+    
+    DBClusterInstanceClass?: string;
+    
+    AllocatedStorage?: number;
+    
+    StorageType?: string;
+    
+    Iops?: number;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+}
+export declare namespace ModifyDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterMessage) => any;
+}
+export interface ModifyDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace ModifyDBClusterResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterResult) => any;
+}
+export interface ModifyDBClusterEndpointMessage {
+    
+    DBClusterEndpointIdentifier: string | undefined;
+    
+    EndpointType?: string;
+    
+    StaticMembers?: string[];
+    
+    ExcludedMembers?: string[];
+}
+export declare namespace ModifyDBClusterEndpointMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterEndpointMessage) => any;
+}
+
+export interface DBClusterParameterGroupNameMessage {
+    
+    DBClusterParameterGroupName?: string;
+}
+export declare namespace DBClusterParameterGroupNameMessage {
+    
+    const filterSensitiveLog: (obj: DBClusterParameterGroupNameMessage) => any;
+}
+
+export interface ModifyDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    Parameters: Parameter[] | undefined;
+}
+export declare namespace ModifyDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterParameterGroupMessage) => any;
+}
+
+export interface ModifyDBClusterSnapshotAttributeMessage {
+    
+    DBClusterSnapshotIdentifier: string | undefined;
+    
+    AttributeName: string | undefined;
+    
+    ValuesToAdd?: string[];
+    
+    ValuesToRemove?: string[];
+}
+export declare namespace ModifyDBClusterSnapshotAttributeMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterSnapshotAttributeMessage) => any;
+}
+export interface ModifyDBClusterSnapshotAttributeResult {
+    
+    DBClusterSnapshotAttributesResult?: DBClusterSnapshotAttributesResult;
+}
+export declare namespace ModifyDBClusterSnapshotAttributeResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBClusterSnapshotAttributeResult) => any;
+}
+
+export declare class SharedSnapshotQuotaExceededFault extends __BaseException {
+    readonly name: "SharedSnapshotQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SharedSnapshotQuotaExceededFault, __BaseException>);
+}
+
+export declare class DBUpgradeDependencyFailureFault extends __BaseException {
+    readonly name: "DBUpgradeDependencyFailureFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBUpgradeDependencyFailureFault, __BaseException>);
+}
+
+export interface ModifyDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    AllocatedStorage?: number;
+    
+    DBInstanceClass?: string;
+    
+    DBSubnetGroupName?: string;
+    
+    DBSecurityGroups?: string[];
+    
+    VpcSecurityGroupIds?: string[];
+    
+    ApplyImmediately?: boolean;
+    
+    MasterUserPassword?: string;
+    
+    DBParameterGroupName?: string;
+    
+    BackupRetentionPeriod?: number;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    MultiAZ?: boolean;
+    
+    EngineVersion?: string;
+    
+    AllowMajorVersionUpgrade?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    NewDBInstanceIdentifier?: string;
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    TdeCredentialPassword?: string;
+    
+    CACertificateIdentifier?: string;
+    
+    Domain?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    DBPortNumber?: number;
+    
+    PubliclyAccessible?: boolean;
+    
+    MonitoringRoleArn?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    PromotionTier?: number;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    CloudwatchLogsExportConfiguration?: CloudwatchLogsExportConfiguration;
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    UseDefaultProcessorFeatures?: boolean;
+    
+    DeletionProtection?: boolean;
+    
+    MaxAllocatedStorage?: number;
+    
+    CertificateRotationRestart?: boolean;
+    
+    ReplicaMode?: ReplicaMode | string;
+    
+    EnableCustomerOwnedIp?: boolean;
+    
+    AwsBackupRecoveryPointArn?: string;
+    
+    AutomationMode?: AutomationMode | string;
+    
+    ResumeFullAutomationModeMinutes?: number;
+}
+export declare namespace ModifyDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBInstanceMessage) => any;
+}
+export interface ModifyDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace ModifyDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBInstanceResult) => any;
+}
+
+export interface DBParameterGroupNameMessage {
+    
+    DBParameterGroupName?: string;
+}
+export declare namespace DBParameterGroupNameMessage {
+    
+    const filterSensitiveLog: (obj: DBParameterGroupNameMessage) => any;
+}
+
+export interface ModifyDBParameterGroupMessage {
+    
+    DBParameterGroupName: string | undefined;
+    
+    Parameters: Parameter[] | undefined;
+}
+export declare namespace ModifyDBParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBParameterGroupMessage) => any;
+}
+export interface ModifyDBProxyRequest {
+    
+    DBProxyName: string | undefined;
+    
+    NewDBProxyName?: string;
+    
+    Auth?: UserAuthConfig[];
+    
+    RequireTLS?: boolean;
+    
+    IdleClientTimeout?: number;
+    
+    DebugLogging?: boolean;
+    
+    RoleArn?: string;
+    
+    SecurityGroups?: string[];
+}
+export declare namespace ModifyDBProxyRequest {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyRequest) => any;
+}
+export interface ModifyDBProxyResponse {
+    
+    DBProxy?: DBProxy;
+}
+export declare namespace ModifyDBProxyResponse {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyResponse) => any;
+}
+export interface ModifyDBProxyEndpointRequest {
+    
+    DBProxyEndpointName: string | undefined;
+    
+    NewDBProxyEndpointName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+}
+export declare namespace ModifyDBProxyEndpointRequest {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyEndpointRequest) => any;
+}
+export interface ModifyDBProxyEndpointResponse {
+    
+    DBProxyEndpoint?: DBProxyEndpoint;
+}
+export declare namespace ModifyDBProxyEndpointResponse {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyEndpointResponse) => any;
+}
+
+export interface ConnectionPoolConfiguration {
+    
+    MaxConnectionsPercent?: number;
+    
+    MaxIdleConnectionsPercent?: number;
+    
+    ConnectionBorrowTimeout?: number;
+    
+    SessionPinningFilters?: string[];
+    
+    InitQuery?: string;
+}
+export declare namespace ConnectionPoolConfiguration {
+    
+    const filterSensitiveLog: (obj: ConnectionPoolConfiguration) => any;
+}
+export interface ModifyDBProxyTargetGroupRequest {
+    
+    TargetGroupName: string | undefined;
+    
+    DBProxyName: string | undefined;
+    
+    ConnectionPoolConfig?: ConnectionPoolConfiguration;
+    
+    NewName?: string;
+}
+export declare namespace ModifyDBProxyTargetGroupRequest {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyTargetGroupRequest) => any;
+}
+export interface ModifyDBProxyTargetGroupResponse {
+    
+    DBProxyTargetGroup?: DBProxyTargetGroup;
+}
+export declare namespace ModifyDBProxyTargetGroupResponse {
+    
+    const filterSensitiveLog: (obj: ModifyDBProxyTargetGroupResponse) => any;
+}
+export interface ModifyDBSnapshotMessage {
+    
+    DBSnapshotIdentifier: string | undefined;
+    
+    EngineVersion?: string;
+    
+    OptionGroupName?: string;
+}
+export declare namespace ModifyDBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBSnapshotMessage) => any;
+}
+export interface ModifyDBSnapshotResult {
+    
+    DBSnapshot?: DBSnapshot;
+}
+export declare namespace ModifyDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBSnapshotResult) => any;
+}
+
+export interface ModifyDBSnapshotAttributeMessage {
+    
+    DBSnapshotIdentifier: string | undefined;
+    
+    AttributeName: string | undefined;
+    
+    ValuesToAdd?: string[];
+    
+    ValuesToRemove?: string[];
+}
+export declare namespace ModifyDBSnapshotAttributeMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBSnapshotAttributeMessage) => any;
+}
+export interface ModifyDBSnapshotAttributeResult {
+    
+    DBSnapshotAttributesResult?: DBSnapshotAttributesResult;
+}
+export declare namespace ModifyDBSnapshotAttributeResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBSnapshotAttributeResult) => any;
+}
+
+export interface ModifyDBSubnetGroupMessage {
+    
+    DBSubnetGroupName: string | undefined;
+    
+    DBSubnetGroupDescription?: string;
+    
+    SubnetIds: string[] | undefined;
+}
+export declare namespace ModifyDBSubnetGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyDBSubnetGroupMessage) => any;
+}
+export interface ModifyDBSubnetGroupResult {
+    
+    DBSubnetGroup?: DBSubnetGroup;
+}
+export declare namespace ModifyDBSubnetGroupResult {
+    
+    const filterSensitiveLog: (obj: ModifyDBSubnetGroupResult) => any;
+}
+
+export declare class SubnetAlreadyInUse extends __BaseException {
+    readonly name: "SubnetAlreadyInUse";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SubnetAlreadyInUse, __BaseException>);
+}
+
+export interface ModifyEventSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SnsTopicArn?: string;
+    
+    SourceType?: string;
+    
+    EventCategories?: string[];
+    
+    Enabled?: boolean;
+}
+export declare namespace ModifyEventSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionMessage) => any;
+}
+export interface ModifyEventSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace ModifyEventSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: ModifyEventSubscriptionResult) => any;
+}
+export interface ModifyGlobalClusterMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    NewGlobalClusterIdentifier?: string;
+    
+    DeletionProtection?: boolean;
+    
+    EngineVersion?: string;
+    
+    AllowMajorVersionUpgrade?: boolean;
+}
+export declare namespace ModifyGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: ModifyGlobalClusterMessage) => any;
+}
+export interface ModifyGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace ModifyGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: ModifyGlobalClusterResult) => any;
+}
+
+export interface OptionConfiguration {
+    
+    OptionName: string | undefined;
+    
+    Port?: number;
+    
+    OptionVersion?: string;
+    
+    DBSecurityGroupMemberships?: string[];
+    
+    VpcSecurityGroupMemberships?: string[];
+    
+    OptionSettings?: OptionSetting[];
+}
+export declare namespace OptionConfiguration {
+    
+    const filterSensitiveLog: (obj: OptionConfiguration) => any;
+}
+
+export interface ModifyOptionGroupMessage {
+    
+    OptionGroupName: string | undefined;
+    
+    OptionsToInclude?: OptionConfiguration[];
+    
+    OptionsToRemove?: string[];
+    
+    ApplyImmediately?: boolean;
+}
+export declare namespace ModifyOptionGroupMessage {
+    
+    const filterSensitiveLog: (obj: ModifyOptionGroupMessage) => any;
+}
+export interface ModifyOptionGroupResult {
+    
+    OptionGroup?: OptionGroup;
+}
+export declare namespace ModifyOptionGroupResult {
+    
+    const filterSensitiveLog: (obj: ModifyOptionGroupResult) => any;
+}
+
+export interface PromoteReadReplicaMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    BackupRetentionPeriod?: number;
+    
+    PreferredBackupWindow?: string;
+}
+export declare namespace PromoteReadReplicaMessage {
+    
+    const filterSensitiveLog: (obj: PromoteReadReplicaMessage) => any;
+}
+export interface PromoteReadReplicaResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace PromoteReadReplicaResult {
+    
+    const filterSensitiveLog: (obj: PromoteReadReplicaResult) => any;
+}
+
+export interface PromoteReadReplicaDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace PromoteReadReplicaDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: PromoteReadReplicaDBClusterMessage) => any;
+}
+export interface PromoteReadReplicaDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace PromoteReadReplicaDBClusterResult {
+    
+    const filterSensitiveLog: (obj: PromoteReadReplicaDBClusterResult) => any;
+}
+
+export interface PurchaseReservedDBInstancesOfferingMessage {
+    
+    ReservedDBInstancesOfferingId: string | undefined;
+    
+    ReservedDBInstanceId?: string;
+    
+    DBInstanceCount?: number;
+    
+    Tags?: Tag[];
+}
+export declare namespace PurchaseReservedDBInstancesOfferingMessage {
+    
+    const filterSensitiveLog: (obj: PurchaseReservedDBInstancesOfferingMessage) => any;
+}
+export interface PurchaseReservedDBInstancesOfferingResult {
+    
+    ReservedDBInstance?: ReservedDBInstance;
+}
+export declare namespace PurchaseReservedDBInstancesOfferingResult {
+    
+    const filterSensitiveLog: (obj: PurchaseReservedDBInstancesOfferingResult) => any;
+}
+
+export declare class ReservedDBInstanceAlreadyExistsFault extends __BaseException {
+    readonly name: "ReservedDBInstanceAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedDBInstanceAlreadyExistsFault, __BaseException>);
+}
+
+export declare class ReservedDBInstanceQuotaExceededFault extends __BaseException {
+    readonly name: "ReservedDBInstanceQuotaExceededFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReservedDBInstanceQuotaExceededFault, __BaseException>);
+}
+export interface RebootDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace RebootDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: RebootDBClusterMessage) => any;
+}
+export interface RebootDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RebootDBClusterResult {
+    
+    const filterSensitiveLog: (obj: RebootDBClusterResult) => any;
+}
+
+export interface RebootDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    ForceFailover?: boolean;
+}
+export declare namespace RebootDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceMessage) => any;
+}
+export interface RebootDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RebootDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceResult) => any;
+}
+
+export declare class DBProxyTargetAlreadyRegisteredFault extends __BaseException {
+    readonly name: "DBProxyTargetAlreadyRegisteredFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBProxyTargetAlreadyRegisteredFault, __BaseException>);
+}
+
+export declare class InsufficientAvailableIPsInSubnetFault extends __BaseException {
+    readonly name: "InsufficientAvailableIPsInSubnetFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientAvailableIPsInSubnetFault, __BaseException>);
+}
+export interface RegisterDBProxyTargetsRequest {
+    
+    DBProxyName: string | undefined;
+    
+    TargetGroupName?: string;
+    
+    DBInstanceIdentifiers?: string[];
+    
+    DBClusterIdentifiers?: string[];
+}
+export declare namespace RegisterDBProxyTargetsRequest {
+    
+    const filterSensitiveLog: (obj: RegisterDBProxyTargetsRequest) => any;
+}
+export interface RegisterDBProxyTargetsResponse {
+    
+    DBProxyTargets?: DBProxyTarget[];
+}
+export declare namespace RegisterDBProxyTargetsResponse {
+    
+    const filterSensitiveLog: (obj: RegisterDBProxyTargetsResponse) => any;
+}
+export interface RemoveFromGlobalClusterMessage {
+    
+    GlobalClusterIdentifier?: string;
+    
+    DbClusterIdentifier?: string;
+}
+export declare namespace RemoveFromGlobalClusterMessage {
+    
+    const filterSensitiveLog: (obj: RemoveFromGlobalClusterMessage) => any;
+}
+export interface RemoveFromGlobalClusterResult {
+    
+    GlobalCluster?: GlobalCluster;
+}
+export declare namespace RemoveFromGlobalClusterResult {
+    
+    const filterSensitiveLog: (obj: RemoveFromGlobalClusterResult) => any;
+}
+
+export declare class DBClusterRoleNotFoundFault extends __BaseException {
+    readonly name: "DBClusterRoleNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBClusterRoleNotFoundFault, __BaseException>);
+}
+export interface RemoveRoleFromDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName?: string;
+}
+export declare namespace RemoveRoleFromDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: RemoveRoleFromDBClusterMessage) => any;
+}
+
+export declare class DBInstanceRoleNotFoundFault extends __BaseException {
+    readonly name: "DBInstanceRoleNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DBInstanceRoleNotFoundFault, __BaseException>);
+}
+export interface RemoveRoleFromDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName: string | undefined;
+}
+export declare namespace RemoveRoleFromDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: RemoveRoleFromDBInstanceMessage) => any;
+}
+
+export interface RemoveSourceIdentifierFromSubscriptionMessage {
+    
+    SubscriptionName: string | undefined;
+    
+    SourceIdentifier: string | undefined;
+}
+export declare namespace RemoveSourceIdentifierFromSubscriptionMessage {
+    
+    const filterSensitiveLog: (obj: RemoveSourceIdentifierFromSubscriptionMessage) => any;
+}
+export interface RemoveSourceIdentifierFromSubscriptionResult {
+    
+    EventSubscription?: EventSubscription;
+}
+export declare namespace RemoveSourceIdentifierFromSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: RemoveSourceIdentifierFromSubscriptionResult) => any;
+}
+
+export interface RemoveTagsFromResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace RemoveTagsFromResourceMessage {
+    
+    const filterSensitiveLog: (obj: RemoveTagsFromResourceMessage) => any;
+}
+
+export interface ResetDBClusterParameterGroupMessage {
+    
+    DBClusterParameterGroupName: string | undefined;
+    
+    ResetAllParameters?: boolean;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace ResetDBClusterParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ResetDBClusterParameterGroupMessage) => any;
+}
+
+export interface ResetDBParameterGroupMessage {
+    
+    DBParameterGroupName: string | undefined;
+    
+    ResetAllParameters?: boolean;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace ResetDBParameterGroupMessage {
+    
+    const filterSensitiveLog: (obj: ResetDBParameterGroupMessage) => any;
+}
+
+export declare class InvalidS3BucketFault extends __BaseException {
+    readonly name: "InvalidS3BucketFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3BucketFault, __BaseException>);
+}
+export interface RestoreDBClusterFromS3Message {
+    
+    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 | undefined;
+    
+    MasterUserPassword: string | undefined;
+    
+    OptionGroupName?: string;
+    
+    PreferredBackupWindow?: string;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    Tags?: Tag[];
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    SourceEngine: string | undefined;
+    
+    SourceEngineVersion: string | undefined;
+    
+    S3BucketName: string | undefined;
+    
+    S3Prefix?: string;
+    
+    S3IngestionRoleArn: string | undefined;
+    
+    BacktrackWindow?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    DeletionProtection?: boolean;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+}
+export declare namespace RestoreDBClusterFromS3Message {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromS3Message) => any;
+}
+export interface RestoreDBClusterFromS3Result {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RestoreDBClusterFromS3Result {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromS3Result) => any;
+}
+
+export declare class InsufficientDBClusterCapacityFault extends __BaseException {
+    readonly name: "InsufficientDBClusterCapacityFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDBClusterCapacityFault, __BaseException>);
+}
+
+export declare class InvalidRestoreFault extends __BaseException {
+    readonly name: "InvalidRestoreFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRestoreFault, __BaseException>);
+}
+
+export interface RestoreDBClusterFromSnapshotMessage {
+    
+    AvailabilityZones?: string[];
+    
+    DBClusterIdentifier: string | undefined;
+    
+    SnapshotIdentifier: string | undefined;
+    
+    Engine: string | undefined;
+    
+    EngineVersion?: string;
+    
+    Port?: number;
+    
+    DBSubnetGroupName?: string;
+    
+    DatabaseName?: string;
+    
+    OptionGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    BacktrackWindow?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    EngineMode?: string;
+    
+    ScalingConfiguration?: ScalingConfiguration;
+    
+    DBClusterParameterGroupName?: string;
+    
+    DeletionProtection?: boolean;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    DBClusterInstanceClass?: string;
+    
+    StorageType?: string;
+    
+    Iops?: number;
+    
+    PubliclyAccessible?: boolean;
+}
+export declare namespace RestoreDBClusterFromSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromSnapshotMessage) => any;
+}
+export interface RestoreDBClusterFromSnapshotResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RestoreDBClusterFromSnapshotResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterFromSnapshotResult) => any;
+}
+
+export interface RestoreDBClusterToPointInTimeMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    RestoreType?: string;
+    
+    SourceDBClusterIdentifier: string | undefined;
+    
+    RestoreToTime?: Date;
+    
+    UseLatestRestorableTime?: boolean;
+    
+    Port?: number;
+    
+    DBSubnetGroupName?: string;
+    
+    OptionGroupName?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Tags?: Tag[];
+    
+    KmsKeyId?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    BacktrackWindow?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    DBClusterParameterGroupName?: string;
+    
+    DeletionProtection?: boolean;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    ScalingConfiguration?: ScalingConfiguration;
+    
+    EngineMode?: string;
+    
+    DBClusterInstanceClass?: string;
+    
+    StorageType?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    Iops?: number;
+}
+export declare namespace RestoreDBClusterToPointInTimeMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterToPointInTimeMessage) => any;
+}
+export interface RestoreDBClusterToPointInTimeResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace RestoreDBClusterToPointInTimeResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBClusterToPointInTimeResult) => any;
+}
+
+export interface RestoreDBInstanceFromDBSnapshotMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    DBSnapshotIdentifier: string | undefined;
+    
+    DBInstanceClass?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    DBSubnetGroupName?: string;
+    
+    MultiAZ?: boolean;
+    
+    PubliclyAccessible?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    LicenseModel?: string;
+    
+    DBName?: string;
+    
+    Engine?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    Tags?: Tag[];
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    TdeCredentialPassword?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Domain?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    DomainIAMRoleName?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    UseDefaultProcessorFeatures?: boolean;
+    
+    DBParameterGroupName?: string;
+    
+    DeletionProtection?: boolean;
+    
+    EnableCustomerOwnedIp?: boolean;
+    
+    CustomIamInstanceProfile?: string;
+    
+    BackupTarget?: string;
+}
+export declare namespace RestoreDBInstanceFromDBSnapshotMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceFromDBSnapshotMessage) => any;
+}
+export interface RestoreDBInstanceFromDBSnapshotResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RestoreDBInstanceFromDBSnapshotResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceFromDBSnapshotResult) => any;
+}
+export interface RestoreDBInstanceFromS3Message {
+    
+    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;
+    
+    PubliclyAccessible?: boolean;
+    
+    Tags?: Tag[];
+    
+    StorageType?: string;
+    
+    StorageEncrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    SourceEngine: string | undefined;
+    
+    SourceEngineVersion: string | undefined;
+    
+    S3BucketName: string | undefined;
+    
+    S3Prefix?: string;
+    
+    S3IngestionRoleArn: string | undefined;
+    
+    EnablePerformanceInsights?: boolean;
+    
+    PerformanceInsightsKMSKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    UseDefaultProcessorFeatures?: boolean;
+    
+    DeletionProtection?: boolean;
+    
+    MaxAllocatedStorage?: number;
+}
+export declare namespace RestoreDBInstanceFromS3Message {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceFromS3Message) => any;
+}
+export interface RestoreDBInstanceFromS3Result {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RestoreDBInstanceFromS3Result {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceFromS3Result) => any;
+}
+
+export declare class PointInTimeRestoreNotEnabledFault extends __BaseException {
+    readonly name: "PointInTimeRestoreNotEnabledFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PointInTimeRestoreNotEnabledFault, __BaseException>);
+}
+
+export interface RestoreDBInstanceToPointInTimeMessage {
+    
+    SourceDBInstanceIdentifier?: string;
+    
+    TargetDBInstanceIdentifier: string | undefined;
+    
+    RestoreTime?: Date;
+    
+    UseLatestRestorableTime?: boolean;
+    
+    DBInstanceClass?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    DBSubnetGroupName?: string;
+    
+    MultiAZ?: boolean;
+    
+    PubliclyAccessible?: boolean;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    LicenseModel?: string;
+    
+    DBName?: string;
+    
+    Engine?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    Tags?: Tag[];
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    TdeCredentialPassword?: string;
+    
+    VpcSecurityGroupIds?: string[];
+    
+    Domain?: string;
+    
+    DomainIAMRoleName?: string;
+    
+    EnableIAMDatabaseAuthentication?: boolean;
+    
+    EnableCloudwatchLogsExports?: string[];
+    
+    ProcessorFeatures?: ProcessorFeature[];
+    
+    UseDefaultProcessorFeatures?: boolean;
+    
+    DBParameterGroupName?: string;
+    
+    DeletionProtection?: boolean;
+    
+    SourceDbiResourceId?: string;
+    
+    MaxAllocatedStorage?: number;
+    
+    SourceDBInstanceAutomatedBackupsArn?: string;
+    
+    EnableCustomerOwnedIp?: boolean;
+    
+    CustomIamInstanceProfile?: string;
+    
+    BackupTarget?: string;
+}
+export declare namespace RestoreDBInstanceToPointInTimeMessage {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceToPointInTimeMessage) => any;
+}
+export interface RestoreDBInstanceToPointInTimeResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RestoreDBInstanceToPointInTimeResult {
+    
+    const filterSensitiveLog: (obj: RestoreDBInstanceToPointInTimeResult) => any;
+}
+
+export interface RevokeDBSecurityGroupIngressMessage {
+    
+    DBSecurityGroupName: string | undefined;
+    
+    CIDRIP?: string;
+    
+    EC2SecurityGroupName?: string;
+    
+    EC2SecurityGroupId?: string;
+    
+    EC2SecurityGroupOwnerId?: string;
+}
+export declare namespace RevokeDBSecurityGroupIngressMessage {
+    
+    const filterSensitiveLog: (obj: RevokeDBSecurityGroupIngressMessage) => any;
+}
+export interface RevokeDBSecurityGroupIngressResult {
+    
+    DBSecurityGroup?: DBSecurityGroup;
+}
+export declare namespace RevokeDBSecurityGroupIngressResult {
+    
+    const filterSensitiveLog: (obj: RevokeDBSecurityGroupIngressResult) => any;
+}
+export interface StartActivityStreamRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Mode: ActivityStreamMode | string | undefined;
+    
+    KmsKeyId: string | undefined;
+    
+    ApplyImmediately?: boolean;
+    
+    EngineNativeAuditFieldsIncluded?: boolean;
+}
+export declare namespace StartActivityStreamRequest {
+    
+    const filterSensitiveLog: (obj: StartActivityStreamRequest) => any;
+}
+export interface StartActivityStreamResponse {
+    
+    KmsKeyId?: string;
+    
+    KinesisStreamName?: string;
+    
+    Status?: ActivityStreamStatus | string;
+    
+    Mode?: ActivityStreamMode | string;
+    
+    ApplyImmediately?: boolean;
+    
+    EngineNativeAuditFieldsIncluded?: boolean;
+}
+export declare namespace StartActivityStreamResponse {
+    
+    const filterSensitiveLog: (obj: StartActivityStreamResponse) => any;
+}
+export interface StartDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace StartDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: StartDBClusterMessage) => any;
+}
+export interface StartDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace StartDBClusterResult {
+    
+    const filterSensitiveLog: (obj: StartDBClusterResult) => any;
+}
+export interface StartDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+}
+export declare namespace StartDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: StartDBInstanceMessage) => any;
+}
+export interface StartDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace StartDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: StartDBInstanceResult) => any;
+}
+export interface StartDBInstanceAutomatedBackupsReplicationMessage {
+    
+    SourceDBInstanceArn: string | undefined;
+    
+    BackupRetentionPeriod?: number;
+    
+    KmsKeyId?: string;
+    
+    PreSignedUrl?: string;
+}
+export declare namespace StartDBInstanceAutomatedBackupsReplicationMessage {
+    
+    const filterSensitiveLog: (obj: StartDBInstanceAutomatedBackupsReplicationMessage) => any;
+}
+export interface StartDBInstanceAutomatedBackupsReplicationResult {
+    
+    DBInstanceAutomatedBackup?: DBInstanceAutomatedBackup;
+}
+export declare namespace StartDBInstanceAutomatedBackupsReplicationResult {
+    
+    const filterSensitiveLog: (obj: StartDBInstanceAutomatedBackupsReplicationResult) => any;
+}
+
+export declare class ExportTaskAlreadyExistsFault extends __BaseException {
+    readonly name: "ExportTaskAlreadyExistsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ExportTaskAlreadyExistsFault, __BaseException>);
+}
+
+export declare class IamRoleMissingPermissionsFault extends __BaseException {
+    readonly name: "IamRoleMissingPermissionsFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<IamRoleMissingPermissionsFault, __BaseException>);
+}
+
+export declare class IamRoleNotFoundFault extends __BaseException {
+    readonly name: "IamRoleNotFoundFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<IamRoleNotFoundFault, __BaseException>);
+}
+
+export declare class InvalidExportOnlyFault extends __BaseException {
+    readonly name: "InvalidExportOnlyFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidExportOnlyFault, __BaseException>);
+}
+
+export declare class InvalidExportSourceStateFault extends __BaseException {
+    readonly name: "InvalidExportSourceStateFault";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidExportSourceStateFault, __BaseException>);
+}
+export interface StartExportTaskMessage {
+    
+    ExportTaskIdentifier: string | undefined;
+    
+    SourceArn: string | undefined;
+    
+    S3BucketName: string | undefined;
+    
+    IamRoleArn: string | undefined;
+    
+    KmsKeyId: string | undefined;
+    
+    S3Prefix?: string;
+    
+    ExportOnly?: string[];
+}
+export declare namespace StartExportTaskMessage {
+    
+    const filterSensitiveLog: (obj: StartExportTaskMessage) => any;
+}
+export interface StopActivityStreamRequest {
+    
+    ResourceArn: string | undefined;
+    
+    ApplyImmediately?: boolean;
+}
+export declare namespace StopActivityStreamRequest {
+    
+    const filterSensitiveLog: (obj: StopActivityStreamRequest) => any;
+}
+export interface StopActivityStreamResponse {
+    
+    KmsKeyId?: string;
+    
+    KinesisStreamName?: string;
+    
+    Status?: ActivityStreamStatus | string;
+}
+export declare namespace StopActivityStreamResponse {
+    
+    const filterSensitiveLog: (obj: StopActivityStreamResponse) => any;
+}
+export interface StopDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+}
+export declare namespace StopDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: StopDBClusterMessage) => any;
+}
+export interface StopDBClusterResult {
+    
+    DBCluster?: DBCluster;
+}
+export declare namespace StopDBClusterResult {
+    
+    const filterSensitiveLog: (obj: StopDBClusterResult) => any;
+}
+export interface StopDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    DBSnapshotIdentifier?: string;
+}
+export declare namespace StopDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: StopDBInstanceMessage) => any;
+}
+export interface StopDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace StopDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: StopDBInstanceResult) => any;
+}
+export interface StopDBInstanceAutomatedBackupsReplicationMessage {
+    
+    SourceDBInstanceArn: string | undefined;
+}
+export declare namespace StopDBInstanceAutomatedBackupsReplicationMessage {
+    
+    const filterSensitiveLog: (obj: StopDBInstanceAutomatedBackupsReplicationMessage) => any;
+}
+export interface StopDBInstanceAutomatedBackupsReplicationResult {
+    
+    DBInstanceAutomatedBackup?: DBInstanceAutomatedBackup;
+}
+export declare namespace StopDBInstanceAutomatedBackupsReplicationResult {
+    
+    const filterSensitiveLog: (obj: StopDBInstanceAutomatedBackupsReplicationResult) => any;
+}