@aws-sdk/client-rds 3.34.0 → 3.37.0

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

@@ -0,0 +1,2652 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ActivityStreamMode, ActivityStreamStatus, AvailabilityZone, Certificate, DBCluster, DBClusterSnapshotAttributesResult, DBInstance, DBInstanceAutomatedBackup, DBProxy, DBProxyEndpoint, DBProxyTarget, DBProxyTargetGroup, DBSecurityGroup, DBSnapshot, DBSubnetGroup, EventSubscription, ExportTask, Filter, GlobalCluster, InstallationMedia, OptionGroup, OptionSetting, Parameter, ProcessorFeature, ReplicaMode, ResourcePendingMaintenanceActions, ScalingConfiguration, Tag, UserAuthConfig } from "./models_0";
+
+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 = "db-cluster" | "db-cluster-snapshot" | "db-instance" | "db-parameter-group" | "db-security-group" | "db-snapshot";
+
+export interface DescribeEventsMessage {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Duration?: number;
+    
+    EventCategories?: string[];
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventsMessage) => any;
+}
+
+export interface Event {
+    
+    SourceIdentifier?: string;
+    
+    SourceType?: SourceType | string;
+    
+    Message?: string;
+    
+    EventCategories?: string[];
+    
+    Date?: Date;
+    
+    SourceArn?: string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface EventsMessage {
+    
+    Marker?: string;
+    
+    Events?: Event[];
+}
+export declare namespace EventsMessage {
+    
+    const filterSensitiveLog: (obj: EventsMessage) => any;
+}
+
+export interface DescribeEventSubscriptionsMessage {
+    
+    SubscriptionName?: string;
+    
+    Filters?: Filter[];
+    
+    MaxRecords?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeEventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventSubscriptionsMessage) => any;
+}
+
+export interface EventSubscriptionsMessage {
+    
+    Marker?: string;
+    
+    EventSubscriptionsList?: EventSubscription[];
+}
+export declare namespace EventSubscriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EventSubscriptionsMessage) => any;
+}
+export interface 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;
+}
+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 interface ReservedDBInstanceNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedDBInstanceNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedDBInstanceNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstanceNotFoundFault) => any;
+}
+
+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 interface ReservedDBInstancesOfferingNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedDBInstancesOfferingNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedDBInstancesOfferingNotFoundFault {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstancesOfferingNotFoundFault) => any;
+}
+
+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 interface DBLogFileNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBLogFileNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBLogFileNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBLogFileNotFoundFault) => any;
+}
+
+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 interface InstallationMediaAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "InstallationMediaAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InstallationMediaAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: InstallationMediaAlreadyExistsFault) => any;
+}
+
+export interface ListTagsForResourceMessage {
+    
+    ResourceName: string | undefined;
+    
+    Filters?: Filter[];
+}
+export declare namespace ListTagsForResourceMessage {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceMessage) => any;
+}
+
+export interface TagListMessage {
+    
+    TagList?: Tag[];
+}
+export declare namespace TagListMessage {
+    
+    const filterSensitiveLog: (obj: TagListMessage) => any;
+}
+export 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 interface InvalidDBClusterCapacityFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidDBClusterCapacityFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidDBClusterCapacityFault {
+    
+    const filterSensitiveLog: (obj: InvalidDBClusterCapacityFault) => any;
+}
+export interface ModifyCurrentDBClusterCapacityMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    Capacity?: number;
+    
+    SecondsBeforeTimeout?: number;
+    
+    TimeoutAction?: string;
+}
+export declare namespace ModifyCurrentDBClusterCapacityMessage {
+    
+    const filterSensitiveLog: (obj: ModifyCurrentDBClusterCapacityMessage) => 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;
+}
+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 interface SharedSnapshotQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "SharedSnapshotQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SharedSnapshotQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: SharedSnapshotQuotaExceededFault) => any;
+}
+
+export interface DBUpgradeDependencyFailureFault extends __SmithyException, $MetadataBearer {
+    name: "DBUpgradeDependencyFailureFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBUpgradeDependencyFailureFault {
+    
+    const filterSensitiveLog: (obj: DBUpgradeDependencyFailureFault) => any;
+}
+
+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;
+}
+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 interface SubnetAlreadyInUse extends __SmithyException, $MetadataBearer {
+    name: "SubnetAlreadyInUse";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace SubnetAlreadyInUse {
+    
+    const filterSensitiveLog: (obj: SubnetAlreadyInUse) => any;
+}
+
+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 interface ReservedDBInstanceAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedDBInstanceAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedDBInstanceAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstanceAlreadyExistsFault) => any;
+}
+
+export interface ReservedDBInstanceQuotaExceededFault extends __SmithyException, $MetadataBearer {
+    name: "ReservedDBInstanceQuotaExceededFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ReservedDBInstanceQuotaExceededFault {
+    
+    const filterSensitiveLog: (obj: ReservedDBInstanceQuotaExceededFault) => any;
+}
+
+export interface RebootDBInstanceMessage {
+    
+    DBInstanceIdentifier: string | undefined;
+    
+    ForceFailover?: boolean;
+}
+export declare namespace RebootDBInstanceMessage {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceMessage) => any;
+}
+export interface RebootDBInstanceResult {
+    
+    DBInstance?: DBInstance;
+}
+export declare namespace RebootDBInstanceResult {
+    
+    const filterSensitiveLog: (obj: RebootDBInstanceResult) => any;
+}
+
+export interface DBProxyTargetAlreadyRegisteredFault extends __SmithyException, $MetadataBearer {
+    name: "DBProxyTargetAlreadyRegisteredFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBProxyTargetAlreadyRegisteredFault {
+    
+    const filterSensitiveLog: (obj: DBProxyTargetAlreadyRegisteredFault) => any;
+}
+
+export interface InsufficientAvailableIPsInSubnetFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientAvailableIPsInSubnetFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientAvailableIPsInSubnetFault {
+    
+    const filterSensitiveLog: (obj: InsufficientAvailableIPsInSubnetFault) => any;
+}
+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 interface DBClusterRoleNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBClusterRoleNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBClusterRoleNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBClusterRoleNotFoundFault) => any;
+}
+export interface RemoveRoleFromDBClusterMessage {
+    
+    DBClusterIdentifier: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FeatureName?: string;
+}
+export declare namespace RemoveRoleFromDBClusterMessage {
+    
+    const filterSensitiveLog: (obj: RemoveRoleFromDBClusterMessage) => any;
+}
+
+export interface DBInstanceRoleNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "DBInstanceRoleNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DBInstanceRoleNotFoundFault {
+    
+    const filterSensitiveLog: (obj: DBInstanceRoleNotFoundFault) => any;
+}
+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 interface InvalidS3BucketFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3BucketFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidS3BucketFault {
+    
+    const filterSensitiveLog: (obj: InvalidS3BucketFault) => any;
+}
+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 interface InsufficientDBClusterCapacityFault extends __SmithyException, $MetadataBearer {
+    name: "InsufficientDBClusterCapacityFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InsufficientDBClusterCapacityFault {
+    
+    const filterSensitiveLog: (obj: InsufficientDBClusterCapacityFault) => any;
+}
+
+export interface InvalidRestoreFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidRestoreFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidRestoreFault {
+    
+    const filterSensitiveLog: (obj: InvalidRestoreFault) => any;
+}
+
+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;
+}
+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;
+}
+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;
+}
+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 interface PointInTimeRestoreNotEnabledFault extends __SmithyException, $MetadataBearer {
+    name: "PointInTimeRestoreNotEnabledFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace PointInTimeRestoreNotEnabledFault {
+    
+    const filterSensitiveLog: (obj: PointInTimeRestoreNotEnabledFault) => any;
+}
+
+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;
+}
+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 interface ExportTaskAlreadyExistsFault extends __SmithyException, $MetadataBearer {
+    name: "ExportTaskAlreadyExistsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ExportTaskAlreadyExistsFault {
+    
+    const filterSensitiveLog: (obj: ExportTaskAlreadyExistsFault) => any;
+}
+
+export interface IamRoleMissingPermissionsFault extends __SmithyException, $MetadataBearer {
+    name: "IamRoleMissingPermissionsFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace IamRoleMissingPermissionsFault {
+    
+    const filterSensitiveLog: (obj: IamRoleMissingPermissionsFault) => any;
+}
+
+export interface IamRoleNotFoundFault extends __SmithyException, $MetadataBearer {
+    name: "IamRoleNotFoundFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace IamRoleNotFoundFault {
+    
+    const filterSensitiveLog: (obj: IamRoleNotFoundFault) => any;
+}
+
+export interface InvalidExportOnlyFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidExportOnlyFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidExportOnlyFault {
+    
+    const filterSensitiveLog: (obj: InvalidExportOnlyFault) => any;
+}
+
+export interface InvalidExportSourceStateFault extends __SmithyException, $MetadataBearer {
+    name: "InvalidExportSourceStateFault";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidExportSourceStateFault {
+    
+    const filterSensitiveLog: (obj: InvalidExportSourceStateFault) => any;
+}
+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;
+}